From bd7392457a26eca851f939c7dd9d1a3a46996f71 Mon Sep 17 00:00:00 2001 From: Reptile <43194093+gator-boi@users.noreply.github.com> Date: Wed, 21 Jun 2023 10:07:22 -0500 Subject: [PATCH] sui: implement Hello Token example (#51) * sui: implement Hello Token Sui contracts and unit tests * sui: add integration test suite * sui: add documentation * sui: add foreign contracts table directly to state object * sui: remove parenthesis --------- Co-authored-by: gator-boi --- README.md | 19 + sui/.gitignore | 8 + sui/Makefile | 34 + sui/README.md | 58 + sui/contracts/example_coins/Makefile | 15 + sui/contracts/example_coins/Move.devnet.toml | 11 + sui/contracts/example_coins/Move.lock | 20 + sui/contracts/example_coins/Move.toml | 14 + .../example_coins/sources/coin_10.move | 72 + .../example_coins/sources/coin_8.move | 72 + sui/contracts/hello_token/Makefile | 15 + sui/contracts/hello_token/Move.devnet.toml | 18 + sui/contracts/hello_token/Move.lock | 39 + sui/contracts/hello_token/Move.mainnet.toml | 17 + sui/contracts/hello_token/Move.testnet.toml | 17 + sui/contracts/hello_token/Move.toml | 32 + .../sources/datatypes/message.move | 149 + .../sources/datatypes/relayer_fee.move | 113 + .../sources/foreign_contracts.move | 52 + sui/contracts/hello_token/sources/owner.move | 620 +++ sui/contracts/hello_token/sources/state.move | 125 + .../sources/test/dummy_message.move | 58 + .../hello_token/sources/transfer.move | 1365 ++++++ sui/dependencies/scripts/deploy.sh | 89 + sui/env/testing.env | 23 + sui/package.json | 29 + sui/shell-scripts/fetch_wormhole_contracts.sh | 43 + sui/shell-scripts/run_integration_tests.sh | 47 + sui/ts/src/consts.ts | 67 + sui/ts/src/index.ts | 1 + sui/ts/src/utils.ts | 197 + sui/ts/tests/00_environment.ts | 419 ++ sui/ts/tests/02_hello_token.ts | 1211 ++++++ sui/ts/tests/helpers/error.ts | 5 + sui/ts/tests/helpers/index.ts | 2 + sui/ts/tests/sui_config/client.yaml | 12 + sui/ts/tests/sui_config/fullnode.yaml | 45 + sui/ts/tests/sui_config/genesis.blob | Bin 0 -> 202349 bytes sui/ts/tests/sui_config/network.yaml | 297 ++ sui/ts/tests/sui_config/sui.keystore | 7 + .../tests/sui_config/validator-config-0.yaml | 73 + .../tests/sui_config/validator-config-1.yaml | 73 + .../tests/sui_config/validator-config-2.yaml | 73 + .../tests/sui_config/validator-config-3.yaml | 73 + sui/tsconfig.json | 13 + sui/yarn.lock | 3710 +++++++++++++++++ 46 files changed, 9452 insertions(+) create mode 100644 sui/.gitignore create mode 100644 sui/Makefile create mode 100644 sui/README.md create mode 100644 sui/contracts/example_coins/Makefile create mode 100644 sui/contracts/example_coins/Move.devnet.toml create mode 100644 sui/contracts/example_coins/Move.lock create mode 100644 sui/contracts/example_coins/Move.toml create mode 100644 sui/contracts/example_coins/sources/coin_10.move create mode 100644 sui/contracts/example_coins/sources/coin_8.move create mode 100644 sui/contracts/hello_token/Makefile create mode 100644 sui/contracts/hello_token/Move.devnet.toml create mode 100644 sui/contracts/hello_token/Move.lock create mode 100644 sui/contracts/hello_token/Move.mainnet.toml create mode 100644 sui/contracts/hello_token/Move.testnet.toml create mode 100644 sui/contracts/hello_token/Move.toml create mode 100644 sui/contracts/hello_token/sources/datatypes/message.move create mode 100644 sui/contracts/hello_token/sources/datatypes/relayer_fee.move create mode 100644 sui/contracts/hello_token/sources/foreign_contracts.move create mode 100644 sui/contracts/hello_token/sources/owner.move create mode 100644 sui/contracts/hello_token/sources/state.move create mode 100644 sui/contracts/hello_token/sources/test/dummy_message.move create mode 100644 sui/contracts/hello_token/sources/transfer.move create mode 100644 sui/dependencies/scripts/deploy.sh create mode 100644 sui/env/testing.env create mode 100644 sui/package.json create mode 100644 sui/shell-scripts/fetch_wormhole_contracts.sh create mode 100644 sui/shell-scripts/run_integration_tests.sh create mode 100644 sui/ts/src/consts.ts create mode 100644 sui/ts/src/index.ts create mode 100644 sui/ts/src/utils.ts create mode 100644 sui/ts/tests/00_environment.ts create mode 100644 sui/ts/tests/02_hello_token.ts create mode 100644 sui/ts/tests/helpers/error.ts create mode 100644 sui/ts/tests/helpers/index.ts create mode 100644 sui/ts/tests/sui_config/client.yaml create mode 100644 sui/ts/tests/sui_config/fullnode.yaml create mode 100644 sui/ts/tests/sui_config/genesis.blob create mode 100644 sui/ts/tests/sui_config/network.yaml create mode 100644 sui/ts/tests/sui_config/sui.keystore create mode 100644 sui/ts/tests/sui_config/validator-config-0.yaml create mode 100644 sui/ts/tests/sui_config/validator-config-1.yaml create mode 100644 sui/ts/tests/sui_config/validator-config-2.yaml create mode 100644 sui/ts/tests/sui_config/validator-config-3.yaml create mode 100644 sui/tsconfig.json create mode 100644 sui/yarn.lock diff --git a/README.md b/README.md index b6f0331..5764fd0 100644 --- a/README.md +++ b/README.md @@ -12,6 +12,25 @@ If your xChain app will require EVM smart contracts, we recommend using [Foundry If your xChain app will require Solana programs, prepare your development environment by installing [Solana and Anchor dependencies](https://book.anchor-lang.com/getting_started/installation.html), which include `solana` and `anchor` CLI tools. +### SUI + +Install the `Sui` CLI. This tool is used to compile the contracts and run the tests. + +```sh +cargo install --locked --git https://github.com/MystenLabs/sui.git --rev 09b2081498366df936abae26eea4b2d5cafb2788 sui sui-faucet +``` + +### Worm CLI + +First, checkout the [Wormhole](https://github.com/wormhole-foundation/wormhole) repo, then install the CLI tool by running: + +```sh +wormhole/clients/js $ make install +``` + +`worm` is the swiss army knife for interacting with wormhole contracts on all +supported chains, and generating signed messages (VAAs) for testing. + ## Build and Test Each directory represents Wormhole integrations for specific blockchain networks. Please navigate diff --git a/sui/.gitignore b/sui/.gitignore new file mode 100644 index 0000000..3f1887a --- /dev/null +++ b/sui/.gitignore @@ -0,0 +1,8 @@ +node_modules +contracts/*/build +sui.log.* +deploy.out +dependencies/wormhole +dependencies/token_bridge +ts/tests/sui_config/authorities_db +ts/tests/sui_config/consensus_db \ No newline at end of file diff --git a/sui/Makefile b/sui/Makefile new file mode 100644 index 0000000..a17e2b6 --- /dev/null +++ b/sui/Makefile @@ -0,0 +1,34 @@ +include env/testing.env + +CONTRACTS := $(wildcard contracts/*/.) + +.PHONY: dependencies all clean build test integration-test $(CONTRACTS) + +all: + +.PHONY: clean +clean: + rm -rf node_modules dependencies/wormhole dependencies/token_bridge ts/tests/sui_config/*_db/ + +dependencies: node_modules dependencies/wormhole/build dependencies/token_bridge/build + +node_modules: + yarn + +dependencies/token_bridge/build: dependencies/wormhole/build + +dependencies/wormhole/build: + bash shell-scripts/fetch_wormhole_contracts.sh + +.PHONY: test +test: unit-test integration-test + +.PHONY: unit-test +unit-test: $(CONTRACTS) + +$(CONTRACTS): + $(MAKE) -C $@ test + +.PHONY: integration-test +integration-test: dependencies + bash shell-scripts/run_integration_tests.sh diff --git a/sui/README.md b/sui/README.md new file mode 100644 index 0000000..91a4bd6 --- /dev/null +++ b/sui/README.md @@ -0,0 +1,58 @@ +# Wormhole Integration in Sui + +These programs are enumerated the same as the other smart contract +subdirectories (e.g. [solana](../solana)). + +## Design Documents + +Read the design documents for each example project (only `HelloToken` is implemented for Sui currently): + +1. [HelloWorld](../docs/01_hello_world.md) +2. [HelloToken](../docs/02_hello_token.md) + +## Dependencies + +Install the `Sui` CLI. This tool is used to compile the contracts and run the tests. + +```sh +cargo install --locked --git https://github.com/MystenLabs/sui.git --rev 09b2081498366df936abae26eea4b2d5cafb2788 sui sui-faucet +``` + +### Worm CLI + +First, checkout the [Wormhole](https://github.com/wormhole-foundation/wormhole) repo, then install the CLI tool by running: + +```sh +wormhole/clients/js $ make install +``` + +`worm` is the swiss army knife for interacting with wormhole contracts on all +supported chains, and generating signed messages (VAAs) for testing. + +## Build + +Run the following commands to install the necessary Wormhole and Token Bridge dependencies: + +``` +make dependencies +``` + +## Testing Environment + +The testing environments can be found in the following locations: + +- [Unit Tests](./contracts/hello_token/) (see the source code) +- [Integration Tests](./ts/tests/02_hello_token.ts) + +You can run the tests with the following commands: + +``` +# Move-based Unit tests +make unit-test + +# local-validator integration tests written in typescript +make integration-test + +# unit tests and local-validator integration tests +make test +``` diff --git a/sui/contracts/example_coins/Makefile b/sui/contracts/example_coins/Makefile new file mode 100644 index 0000000..4dcd4b2 --- /dev/null +++ b/sui/contracts/example_coins/Makefile @@ -0,0 +1,15 @@ +.PHONY: all clean test check + +all: check + +.PHONY: clean +clean: + rm -rf build + +.PHONY: check +check: + sui move build -d + +.PHONY: test +test: + sui move test -d diff --git a/sui/contracts/example_coins/Move.devnet.toml b/sui/contracts/example_coins/Move.devnet.toml new file mode 100644 index 0000000..c0151e9 --- /dev/null +++ b/sui/contracts/example_coins/Move.devnet.toml @@ -0,0 +1,11 @@ +[package] +name = "ExampleCoins" +version = "0.1.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "09b2081498366df936abae26eea4b2d5cafb2788" + +[addresses] +example_coins = "0xbfa8d913ccc41ca8522c2f0b3567097316a70ae0eb00bb290d08f9c9047056ce" diff --git a/sui/contracts/example_coins/Move.lock b/sui/contracts/example_coins/Move.lock new file mode 100644 index 0000000..a48679e --- /dev/null +++ b/sui/contracts/example_coins/Move.lock @@ -0,0 +1,20 @@ +# @generated by Move, please check-in and do not edit manually. + +[move] +version = 0 + +dependencies = [ + { name = "Sui" }, +] + +[[move.package]] +name = "MoveStdlib" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "09b2081498366df936abae26eea4b2d5cafb2788", subdir = "crates/sui-framework/packages/move-stdlib" } + +[[move.package]] +name = "Sui" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "09b2081498366df936abae26eea4b2d5cafb2788", subdir = "crates/sui-framework/packages/sui-framework" } + +dependencies = [ + { name = "MoveStdlib" }, +] diff --git a/sui/contracts/example_coins/Move.toml b/sui/contracts/example_coins/Move.toml new file mode 100644 index 0000000..cc41bda --- /dev/null +++ b/sui/contracts/example_coins/Move.toml @@ -0,0 +1,14 @@ +[package] +name = "ExampleCoins" +version = "0.1.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "09b2081498366df936abae26eea4b2d5cafb2788" + +[addresses] +example_coins = "_" + +[dev-addresses] +example_coins = "0x0" diff --git a/sui/contracts/example_coins/sources/coin_10.move b/sui/contracts/example_coins/sources/coin_10.move new file mode 100644 index 0000000..14abdcf --- /dev/null +++ b/sui/contracts/example_coins/sources/coin_10.move @@ -0,0 +1,72 @@ +module example_coins::coin_10 { + use std::option; + use sui::coin::{Self, TreasuryCap, CoinMetadata}; + use sui::transfer; + use sui::tx_context::{Self, TxContext}; + + /// The type identifier of coin. The coin will have a type + /// tag of kind: `Coin` + /// Make sure that the name of the type matches the module's name. + struct COIN_10 has drop {} + + /// Module initializer is called once on module publish. A treasury + /// cap is sent to the publisher, who then controls minting and burning + fun init(witness: COIN_10, ctx: &mut TxContext) { + let (treasury, metadata) = create_coin(witness, ctx); + transfer::public_freeze_object(metadata); + transfer::public_transfer(treasury, tx_context::sender(ctx)); + } + + fun create_coin( + witness: COIN_10, + ctx: &mut TxContext + ): (TreasuryCap, CoinMetadata) { + coin::create_currency( + witness, + 10, // decimals + b"COIN_10", // symbol + b"10-Decimal Coin", // name + b"", // description + option::none(), // icon_url + ctx + ) + } + + #[test_only] + public fun create_coin_test_only( + ctx: &mut TxContext + ): (TreasuryCap, CoinMetadata) { + create_coin(COIN_10 {}, ctx) + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_10 {}, ctx) + } +} + +#[test_only] +module example_coins::coin_10_tests { + use sui::test_scenario::{Self}; + + use example_coins::coin_10::{Self}; + + #[test] + public fun init_test() { + let my_scenario = test_scenario::begin(@0x0); + let scenario = &mut my_scenario; + let creator = @0xDEADBEEF; + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Init. + coin_10::init_test_only(test_scenario::ctx(scenario)); + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Done. + test_scenario::end(my_scenario); + } +} diff --git a/sui/contracts/example_coins/sources/coin_8.move b/sui/contracts/example_coins/sources/coin_8.move new file mode 100644 index 0000000..a9300f3 --- /dev/null +++ b/sui/contracts/example_coins/sources/coin_8.move @@ -0,0 +1,72 @@ +module example_coins::coin_8 { + use std::option::{Self}; + use sui::coin::{Self, TreasuryCap, CoinMetadata}; + use sui::transfer::{Self}; + use sui::tx_context::{Self, TxContext}; + + /// The type identifier of coin. The coin will have a type + /// tag of kind: `Coin` + /// Make sure that the name of the type matches the module's name. + struct COIN_8 has drop {} + + /// Module initializer is called once on module publish. A treasury + /// cap is sent to the publisher, who then controls minting and burning + fun init(witness: COIN_8, ctx: &mut TxContext) { + let (treasury, metadata) = create_coin(witness, ctx); + transfer::public_freeze_object(metadata); + transfer::public_transfer(treasury, tx_context::sender(ctx)); + } + + fun create_coin( + witness: COIN_8, + ctx: &mut TxContext + ): (TreasuryCap, CoinMetadata) { + coin::create_currency( + witness, + 8, // decimals + b"COIN_8", // symbol + b"8-Decimal Coin", // name + b"", // description + option::none(), // icon_url + ctx + ) + } + + #[test_only] + public fun create_coin_test_only( + ctx: &mut TxContext + ): (TreasuryCap, CoinMetadata) { + create_coin(COIN_8 {}, ctx) + } + + #[test_only] + public fun init_test_only(ctx: &mut TxContext) { + init(COIN_8 {}, ctx) + } +} + +#[test_only] +module example_coins::coin_8_tests { + use sui::test_scenario::{Self}; + + use example_coins::coin_8::{Self}; + + #[test] + public fun init_test() { + let my_scenario = test_scenario::begin(@0x0); + let scenario = &mut my_scenario; + let creator = @0xDEADBEEF; + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Init. + coin_8::init_test_only(test_scenario::ctx(scenario)); + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Done. + test_scenario::end(my_scenario); + } +} diff --git a/sui/contracts/hello_token/Makefile b/sui/contracts/hello_token/Makefile new file mode 100644 index 0000000..3bc6589 --- /dev/null +++ b/sui/contracts/hello_token/Makefile @@ -0,0 +1,15 @@ +.PHONY: all clean test check + +all: check + +.PHONY: clean +clean: + rm -rf build + +.PHONY: check +check: + sui move build -d + +.PHONY: test +test: + sui move test -t 1 diff --git a/sui/contracts/hello_token/Move.devnet.toml b/sui/contracts/hello_token/Move.devnet.toml new file mode 100644 index 0000000..34ba9d2 --- /dev/null +++ b/sui/contracts/hello_token/Move.devnet.toml @@ -0,0 +1,18 @@ +[package] +name = "HelloToken" +version = "0.1.0" +published-at = "0x3b17ab9de6f1f14ee30fc3150e66fb86dbde7cffcbe5e76c108b29633c372120" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "09b2081498366df936abae26eea4b2d5cafb2788" + +[dependencies.Wormhole] +local = "../../dependencies/wormhole" + +[dependencies.TokenBridge] +local = "../../dependencies/token_bridge" + +[addresses] +hello_token = "0x3b17ab9de6f1f14ee30fc3150e66fb86dbde7cffcbe5e76c108b29633c372120" diff --git a/sui/contracts/hello_token/Move.lock b/sui/contracts/hello_token/Move.lock new file mode 100644 index 0000000..ea48cde --- /dev/null +++ b/sui/contracts/hello_token/Move.lock @@ -0,0 +1,39 @@ +# @generated by Move, please check-in and do not edit manually. + +[move] +version = 0 + +dependencies = [ + { name = "Sui" }, + { name = "TokenBridge" }, + { name = "Wormhole" }, +] + +[[move.package]] +name = "MoveStdlib" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "09b2081498366df936abae26eea4b2d5cafb2788", subdir = "crates/sui-framework/packages/move-stdlib" } + +[[move.package]] +name = "Sui" +source = { git = "https://github.com/MystenLabs/sui.git", rev = "09b2081498366df936abae26eea4b2d5cafb2788", subdir = "crates/sui-framework/packages/sui-framework" } + +dependencies = [ + { name = "MoveStdlib" }, +] + +[[move.package]] +name = "TokenBridge" +source = { local = "../../dependencies/token_bridge" } + +dependencies = [ + { name = "Sui" }, + { name = "Wormhole" }, +] + +[[move.package]] +name = "Wormhole" +source = { local = "../../dependencies/wormhole" } + +dependencies = [ + { name = "Sui" }, +] diff --git a/sui/contracts/hello_token/Move.mainnet.toml b/sui/contracts/hello_token/Move.mainnet.toml new file mode 100644 index 0000000..c002833 --- /dev/null +++ b/sui/contracts/hello_token/Move.mainnet.toml @@ -0,0 +1,17 @@ +[package] +name = "HelloToken" +version = "0.1.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "09b2081498366df936abae26eea4b2d5cafb2788" + +[dependencies.Wormhole] +local = "../../dependencies/wormhole" + +[dependencies.TokenBridge] +local = "../../dependencies/token_bridge" + +[addresses] +hello_token = "0x0" diff --git a/sui/contracts/hello_token/Move.testnet.toml b/sui/contracts/hello_token/Move.testnet.toml new file mode 100644 index 0000000..c002833 --- /dev/null +++ b/sui/contracts/hello_token/Move.testnet.toml @@ -0,0 +1,17 @@ +[package] +name = "HelloToken" +version = "0.1.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "09b2081498366df936abae26eea4b2d5cafb2788" + +[dependencies.Wormhole] +local = "../../dependencies/wormhole" + +[dependencies.TokenBridge] +local = "../../dependencies/token_bridge" + +[addresses] +hello_token = "0x0" diff --git a/sui/contracts/hello_token/Move.toml b/sui/contracts/hello_token/Move.toml new file mode 100644 index 0000000..0505ea9 --- /dev/null +++ b/sui/contracts/hello_token/Move.toml @@ -0,0 +1,32 @@ +[package] +name = "HelloToken" +version = "0.1.0" + +[dependencies.Sui] +git = "https://github.com/MystenLabs/sui.git" +subdir = "crates/sui-framework/packages/sui-framework" +rev = "09b2081498366df936abae26eea4b2d5cafb2788" + +[dependencies.Wormhole] +local = "../../dependencies/wormhole" + +[dependencies.TokenBridge] +local = "../../dependencies/token_bridge" + +[addresses] +hello_token = "_" + +[dev-dependencies.Wormhole] +local = "../../dependencies/wormhole" + +[dev-dependencies.TokenBridge] +local = "../../dependencies/token_bridge" + +[dev-dependencies.ExampleCoins] +local = "../example_coins" + +[dev-addresses] +wormhole = "0x69" +token_bridge = "0x420" +hello_token = "0x0" +example_coins = "0x89" diff --git a/sui/contracts/hello_token/sources/datatypes/message.move b/sui/contracts/hello_token/sources/datatypes/message.move new file mode 100644 index 0000000..ca9d140 --- /dev/null +++ b/sui/contracts/hello_token/sources/datatypes/message.move @@ -0,0 +1,149 @@ +/// This module implements serialization and deserialization for the Hello +/// Token message. This message is a specific message encoded as an arbitrary +/// payload via the Wormhole Token Bridge. The `HelloTokenMessage` only +/// has one field, but the following module can serve as a template for +/// more complicated messages. +module hello_token::message { + // Standard lib. + use std::vector; + + // Wormhole dependencies. + use wormhole::cursor; + use wormhole::external_address::{Self, ExternalAddress}; + use wormhole::bytes::{Self}; + + /// Errors. + const E_INVALID_MESSAGE: u64 = 0; + + /// Transfer with relay payload ID. + const MESSAGE_HELLO_TOKEN: u8 = 1; + + /// Container that warehouses transfer information sent from registered + /// Hello Token contracts. + struct HelloTokenMessage has drop { + /// The recipient of the token transfer on the target chain. + recipient: ExternalAddress, + + // This is where other fields can be encoded in a custom + // message in your dapp. + } + + /// Creates new `HelloTokenMessage` type. + public fun new( + recipient: ExternalAddress + ): HelloTokenMessage { + HelloTokenMessage { + recipient + } + } + + /// Encodes a `HelloTokenMessage` message to be sent by the Wormhole + /// Token Bridge. + public fun serialize(transfer_with_relay: HelloTokenMessage): vector { + let encoded = vector::empty(); + + // Message payload ID. + bytes::push_u8(&mut encoded, MESSAGE_HELLO_TOKEN); + + // `recipient` + vector::append( + &mut encoded, + external_address::to_bytes(transfer_with_relay.recipient) + ); + + // Return. + encoded + } + + /// Decodes a `HelloTokenMessage` message into the the `HelloTokenMessage` + /// container. + public fun deserialize(buf: vector): HelloTokenMessage { + let cur = cursor::new(buf); + + // Verify the message type. + assert!( + bytes::take_u8(&mut cur) == MESSAGE_HELLO_TOKEN, + E_INVALID_MESSAGE + ); + + // Deserialize the rest of the payload. + let recipient = external_address::take_bytes(&mut cur); + + // Destory the cursor. + cursor::destroy_empty(cur); + + // Return the deserialized struct. + new( + recipient + ) + } + + // Getters. + + public fun recipient(self: &HelloTokenMessage): ExternalAddress { + self.recipient + } +} + +#[test_only] +module hello_token::message_tests { + // Hello Token modules. + use hello_token::message::{Self}; + + // Wormhole dependencies. + use wormhole::external_address::{Self}; + + // Test consts. + const TEST_HELLO_TOKEN_MESSAGE: vector = x"01000000000000000000000000000000000000000000000000000000000000beef"; + const TEST_RECIPIENT: address = @0xbeef; + + #[test] + public fun new() { + let recipient = external_address::from_address(TEST_RECIPIENT); + + // Create a `HelloTokenMessage` struct. + let transfer_with_relay = message::new( + recipient + ); + + assert!( + recipient == message::recipient(&transfer_with_relay), + 0 + ); + } + + #[test] + public fun serialize() { + let recipient = external_address::from_address(TEST_RECIPIENT); + + // Create a `HelloTokenMessage` struct. + let transfer_with_relay = message::new( + recipient + ); + + // Serialize the struct and confirm it was serialized correctly. + let serialized_transfer_with_relay = message::serialize( + transfer_with_relay + ); + + assert!(serialized_transfer_with_relay == TEST_HELLO_TOKEN_MESSAGE, 0); + } + + #[test] + public fun deserialize() { + // Expected output from parsing the encoded message above. + let recipient = external_address::from_address(TEST_RECIPIENT); + + // Deserialize the `HelloTokenMessage` struct. + let deserialized_transfer_with_relay = + message::deserialize(TEST_HELLO_TOKEN_MESSAGE); + + // Confirm that the deserialized struct is correct. + assert!( + recipient == message::recipient( + &deserialized_transfer_with_relay + ), + 0 + ); + } +} diff --git a/sui/contracts/hello_token/sources/datatypes/relayer_fee.move b/sui/contracts/hello_token/sources/datatypes/relayer_fee.move new file mode 100644 index 0000000..2909397 --- /dev/null +++ b/sui/contracts/hello_token/sources/datatypes/relayer_fee.move @@ -0,0 +1,113 @@ +/// This moudle manages the `RelayerFee` struct. The owner can mutate +/// this struct to update the `relayer_fee` and `relayer_fee_precision`. +module hello_token::relayer_fee { + // Errors. + const E_INVALID_RELAYER_FEE: u64 = 0; + + /// Relayer fee value and fee precision struct. + struct RelayerFee has store, drop { + value: u64, + precision: u64, + } + + /// Creates new `RelayerFee` struct. + public fun new( + fee: u64, + precision: u64 + ): RelayerFee { + assert!(is_valid(fee, precision), E_INVALID_RELAYER_FEE); + RelayerFee { + value: fee, + precision, + } + } + + /// Updates the relayer fee and precision values in a `RelayerFee` struct. + public fun update( + self: &mut RelayerFee, + fee: u64, + precision: u64 + ) { + assert!(is_valid(fee, precision), E_INVALID_RELAYER_FEE); + self.value = fee; + self.precision = precision; + } + + // Getters. + + public fun value(self: &RelayerFee): u64 { + self.value + } + + public fun precision(self: &RelayerFee): u64 { + self.precision + } + + public fun compute( + self: &RelayerFee, + amount: u64 + ): u64 { + let numerator = ((amount as u128) * (self.value as u128)); + ((numerator / (self.precision as u128)) as u64) + } + + // Internal methods. + + fun is_valid(fee: u64, precision: u64): bool { + precision > 0 && fee < precision + } +} + +#[test_only] +module hello_token::relayer_fee_tests { + use hello_token::relayer_fee; + + #[test] + public fun new() { + let fee = 42069; + let precision = 100000; + let params = relayer_fee::new(fee, precision); + + assert!(relayer_fee::value(¶ms) == fee, 0); + assert!(relayer_fee::precision(¶ms) == precision, 0); + } + + #[test] + #[expected_failure(abort_code = 0, location=relayer_fee)] + public fun cannot_new_precision_zero() { + relayer_fee::new(0, 0); + } + + #[test] + #[expected_failure(abort_code = 0, location=relayer_fee)] + public fun cannot_new_precision_gte_fee() { + relayer_fee::new(1, 1); + } + + #[test] + #[expected_failure(abort_code = 0, location=relayer_fee)] + public fun cannot_update_precision_zero() { + let params = relayer_fee::new(42069, 100000); + relayer_fee::update(&mut params, 0, 0); + } + + #[test] + #[expected_failure(abort_code = 0, location=relayer_fee)] + public fun cannot_update_precision_gte_fee() { + let params = relayer_fee::new(42069, 100000); + relayer_fee::update(&mut params, 1, 1); + } + + #[test] + public fun compute() { + let params = relayer_fee::new(42069, 100000); + assert!(relayer_fee::compute(¶ms, 0) == 0, 0); + assert!(relayer_fee::compute(¶ms, 1) == 0, 0); + assert!(relayer_fee::compute(¶ms, 16) == 6, 0); + assert!(relayer_fee::compute(¶ms, 165) == 69, 0); + assert!(relayer_fee::compute(¶ms, 1650) == 694, 0); + assert!(relayer_fee::compute(¶ms, 16502) == 6942, 0); + assert!(relayer_fee::compute(¶ms, 165015) == 69420, 0); + assert!(relayer_fee::compute(¶ms, 1650147) == 694200, 0); + } +} diff --git a/sui/contracts/hello_token/sources/foreign_contracts.move b/sui/contracts/hello_token/sources/foreign_contracts.move new file mode 100644 index 0000000..9852d59 --- /dev/null +++ b/sui/contracts/hello_token/sources/foreign_contracts.move @@ -0,0 +1,52 @@ +/// This module manages the registration process for foreign Token Bridge +/// Relayer contracts. `chain` to `ExternalAddress` mappings are stored +/// as dynamic fields on the `State` object. +module hello_token::foreign_contracts { + // Sui dependencies. + use sui::table::{Self, Table}; + + // Wormhole dependencies. + use wormhole::state::{chain_id}; + use wormhole::external_address::{Self, ExternalAddress}; + + // Errors. + const E_INVALID_CHAIN: u64 = 0; + const E_INVALID_CONTRACT_ADDRESS: u64 = 1; + + // Only state should be able to mutate the `foreign_contracts` dynamic field + // object. + friend hello_token::state; + + /// Adds a new `chain` to `contract_address` mapping. + public(friend) fun add( + foreign_contracts: &mut Table, + chain: u16, + contract_address: ExternalAddress, + ) { + assert!(chain != 0 && chain != chain_id(), E_INVALID_CHAIN); + assert!( + external_address::is_nonzero(&contract_address), + E_INVALID_CONTRACT_ADDRESS + ); + + table::add(foreign_contracts, chain, contract_address); + } + + /// Updates an existing `chain` to `contract_address` mapping. Reverts + /// if the new `contract_address` is the zero address. + public(friend) fun update( + foreign_contracts: &mut Table, + chain: u16, + contract_address: ExternalAddress + ) { + assert!( + external_address::is_nonzero(&contract_address), + E_INVALID_CONTRACT_ADDRESS + ); + + *table::borrow_mut( + foreign_contracts, + chain + ) = contract_address; + } +} diff --git a/sui/contracts/hello_token/sources/owner.move b/sui/contracts/hello_token/sources/owner.move new file mode 100644 index 0000000..ea53a6c --- /dev/null +++ b/sui/contracts/hello_token/sources/owner.move @@ -0,0 +1,620 @@ +/// This module creates an owner capability (OwnerCap). The owner is granted +/// access to certain methods by passing the OwnerCap as an argument. These +/// methods are used to govern the smart contract. +module hello_token::owner { + // Sui dependencies. + use sui::package::{Self, UpgradeCap}; + use sui::dynamic_field::{Self}; + use sui::object::{Self, UID}; + use sui::transfer::{Self}; + use sui::tx_context::{Self, TxContext}; + + // Wormhole dependencies. + use wormhole::external_address::{Self}; + use wormhole::state::{State as WormholeState}; + + // Hello Token dependencies. + use hello_token::state::{Self, State}; + + // Errors. + const E_STATE_ALREADY_CREATED: u64 = 0; + + /// The one of a kind - created in the module initializer. + struct OwnerCap has key, store { + id: UID + } + + /// This function is only called once on module publish. + /// Use it to make sure something has happened only once, like + /// here - only module author will own a version of a + /// `OwnerCap` struct. + fun init(ctx: &mut TxContext) { + // Create `OwnerCap` to the contract publisher. + let owner_cap = OwnerCap { + id: object::new(ctx), + }; + + // Use this in `create_state` to determine if state is created already. + dynamic_field::add(&mut owner_cap.id, b"create_state", true); + + // Transfer `OwnerCap` to the contract publisher. + transfer::transfer(owner_cap, tx_context::sender(ctx)); + } + + /// Only owner. This creates a new state object that also acts as dynamic + /// storage. + public fun create_state( + owner_cap: &mut OwnerCap, + upgrade_cap: UpgradeCap, + wormhole_state: &WormholeState, + relayer_fee: u64, + relayer_fee_precision: u64, + ctx: &mut TxContext + ) { + assert!( + dynamic_field::exists_(&owner_cap.id, b"create_state"), + E_STATE_ALREADY_CREATED + ); + + // State will be created once function finishes. + let _: bool = dynamic_field::remove(&mut owner_cap.id, b"create_state"); + + // Make the contract immutable by destroying the upgrade cap. The caller + // must pass the correct upgrade cap to make this contract immutable. + package::make_immutable(upgrade_cap); + + // Create and share state. + transfer::public_share_object( + state::new( + wormhole_state, + relayer_fee, + relayer_fee_precision, + ctx + ) + ) + } + + /// Only owner. This method registers a foreign Hello Token contract. This + /// allows this contract to receive token transfers from other Hello Token + /// contracts in a trusted way. + public fun register_foreign_contract( + _: &OwnerCap, + t_state: &mut State, + chain: u16, + contract_address: address, + ) { + state::register_foreign_contract( + t_state, + chain, + external_address::from_address(contract_address) + ); + } + + /// Only owner. This method updates the `relayer_fee` and + /// `relayer_fee_precision` for this chain. + public fun update_relayer_fee( + _: &OwnerCap, + t_state: &mut State, + relayer_fee: u64, + relayer_fee_precision: u64 + ) { + state::update_relayer_fee(t_state, relayer_fee, relayer_fee_precision) + } + + #[test_only] + /// We need this function to simulate calling `init` in our test. + public fun init_test_only(ctx: &mut TxContext): UpgradeCap { + init(ctx); + + package::test_publish( + object::id_from_address(@hello_token), + ctx + ) + } +} + +#[test_only] +module hello_token::owner_tests { + // Standard lib. + use std::vector::{Self}; + + // Sui dependencies. + use sui::object::{Self}; + use sui::transfer::{Self}; + use sui::test_scenario::{Self, Scenario, TransactionEffects}; + + // Hello Token dependencies. + use hello_token::state::{State as HelloTokenState}; + use hello_token::owner::{Self, OwnerCap}; + + // Wormhole dependencies. + use wormhole::state::{State as WormholeState}; + use wormhole::external_address::{Self}; + + // Token Bridge dependencies. + use token_bridge::state::{State as BridgeState}; + use token_bridge::register_chain::{Self}; + use token_bridge::token_bridge_scenario::{Self}; + + // Test constants. + const TEST_RELAYER_FEE: u64 = 42069; // 4.2069% + const TEST_RELAYER_FEE_PRECISION: u64 = 1000000; + const TEST_TARGET_CHAIN: u16 = 2; + const TEST_TARGET_CONTRACT: address = + @0x000000000000000000000000beFA429d57cD18b7F8A4d91A2da9AB4AF05d0FBe; + + #[test] + public fun init_test() { + let my_scenario = test_scenario::begin(@0x0); + let scenario = &mut my_scenario; + let (creator, _) = people(); + + // Get things going. + test_scenario::next_tx(scenario, creator); + + // Simulate calling `init`. + { + let upgrade_cap = owner::init_test_only( + test_scenario::ctx(scenario) + ); + + // Check existence of creator and state capabilities. + let effects = test_scenario::next_tx(scenario, creator); + + // Confirm that only one object was created. + let created_ids = test_scenario::created(&effects); + assert!(vector::length(&created_ids) == 1, 0); + + // Verify that the created ID matches the OwnerCap's ID. + let owner_cap_id = vector::borrow(&created_ids, 0); + let owner_cap = + test_scenario::take_from_sender(scenario); + assert!(*owner_cap_id == object::id(&owner_cap), 0); + + // Bye bye. + transfer::public_transfer(upgrade_cap, @0x0); + test_scenario::return_to_sender(scenario, owner_cap); + }; + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + public fun create_state() { + let (creator, _) = people(); + let (my_scenario, effects) = set_up(creator); + let scenario = &mut my_scenario; + + // We expect one object to be created: + // 1. State + let created_ids = test_scenario::created(&effects); + assert!(vector::length(&created_ids) == 1, 0); + + // Verify that the created ID matches the State's ID. + let state_id = vector::borrow(&created_ids, 0); + let state = test_scenario::take_shared(scenario); + assert!(*state_id == object::id(&state), 0); + + // Bye bye. + test_scenario::return_shared(state); + test_scenario::end(my_scenario); + } + + #[test] + public fun register_foreign_contract() { + let (creator, _) = people(); + let (my_scenario, _) = set_up(creator); + let scenario = &mut my_scenario; + + // Fetch the Hello Token state object and owner capability. + let state = test_scenario::take_shared(scenario); + let owner_cap = + test_scenario::take_from_sender(scenario); + + // Verify that the contract isn't already registered. + { + let is_registered = + hello_token::state::contract_registered( + &state, + TEST_TARGET_CHAIN + ); + assert!(!is_registered, 0); + }; + + // Register the emitter. + hello_token::owner::register_foreign_contract( + &owner_cap, + &mut state, + TEST_TARGET_CHAIN, + TEST_TARGET_CONTRACT, + ); + + // Verify that the contract was registered correctly. + { + let is_registered = + hello_token::state::contract_registered(&state, TEST_TARGET_CHAIN); + assert!(is_registered, 0); + + let registered_contract = + hello_token::state::foreign_contract_address( + &state, + TEST_TARGET_CHAIN + ); + assert!( + external_address::to_address( + registered_contract + ) == TEST_TARGET_CONTRACT, + 0 + ); + }; + + // Bye bye. + test_scenario::return_shared(state); + test_scenario::return_to_sender(scenario, owner_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + public fun replace_foreign_contract() { + let (creator, _) = people(); + let (my_scenario, _) = set_up(creator); + let scenario = &mut my_scenario; + + // Create mock chain ID and address pair. + let target_contract_2 = @0x69; + + // Fetch the Hello Token state object and owner capability. + let state = test_scenario::take_shared(scenario); + let owner_cap = + test_scenario::take_from_sender(scenario); + + // Register the emitter. + hello_token::owner::register_foreign_contract( + &owner_cap, + &mut state, + TEST_TARGET_CHAIN, + TEST_TARGET_CONTRACT, + ); + + // Verify that the contract was registered correctly. + { + let is_registered = + hello_token::state::contract_registered(&state, TEST_TARGET_CHAIN); + assert!(is_registered, 0); + + let registered_contract = + hello_token::state::foreign_contract_address( + &state, + TEST_TARGET_CHAIN + ); + assert!( + external_address::to_address( + registered_contract + ) == TEST_TARGET_CONTRACT, + 0 + ); + }; + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Register another emitter with the same chain ID. + hello_token::owner::register_foreign_contract( + &owner_cap, + &mut state, + TEST_TARGET_CHAIN, + target_contract_2, + ); + + // Verify that the contract was registered correctly. + { + let registered_contract = + hello_token::state::foreign_contract_address( + &state, + TEST_TARGET_CHAIN + ); + assert!( + external_address::to_address( + registered_contract + ) == target_contract_2, + 0 + ); + }; + + // Bye bye. + test_scenario::return_shared(state); + test_scenario::return_to_sender(scenario, owner_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = hello_token::foreign_contracts::E_INVALID_CHAIN)] + public fun cannot_register_foreign_contract_chain_id_zero() { + let (creator, _) = people(); + let (my_scenario, _) = set_up(creator); + let scenario = &mut my_scenario; + + // Intentionally set the `target_chain` to zero. + let target_chain: u16 = 0; + + // Fetch the Hello Token state object and owner capability. + let state = test_scenario::take_shared(scenario); + let owner_cap = + test_scenario::take_from_sender(scenario); + + // The `register_foreign_contract` call should fail. + hello_token::owner::register_foreign_contract( + &owner_cap, + &mut state, + target_chain, + TEST_TARGET_CONTRACT, + ); + + // Bye bye. + test_scenario::return_shared(state); + test_scenario::return_to_sender(scenario, owner_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = hello_token::foreign_contracts::E_INVALID_CHAIN)] + public fun cannot_register_foreign_contract_this_chain_id() { + let (creator, _) = people(); + let (my_scenario, _) = set_up(creator); + let scenario = &mut my_scenario; + + // Intentionally set the `target_chain` to 21 (Sui's ID). + let target_chain: u16 = 21; + + // Fetch the Hello Token state object and owner capability. + let state = test_scenario::take_shared(scenario); + let owner_cap = + test_scenario::take_from_sender(scenario); + + // The `register_foreign_contract` call should fail. + hello_token::owner::register_foreign_contract( + &owner_cap, + &mut state, + target_chain, + TEST_TARGET_CONTRACT, + ); + + // Bye bye. + test_scenario::return_shared(state); + test_scenario::return_to_sender(scenario, owner_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = hello_token::foreign_contracts::E_INVALID_CONTRACT_ADDRESS)] + public fun cannot_register_foreign_contract_zero_address() { + let (creator, _) = people(); + let (my_scenario, _) = set_up(creator); + let scenario = &mut my_scenario; + + // Create zero address variable. + let target_contract = @0x0; + + // Fetch the Hello Token state object and owner capability. + let state = test_scenario::take_shared(scenario); + let owner_cap = + test_scenario::take_from_sender(scenario); + + // The `register_foreign_contract` call should fail. + hello_token::owner::register_foreign_contract( + &owner_cap, + &mut state, + TEST_TARGET_CHAIN, + target_contract, + ); + + // Bye bye. + test_scenario::return_shared(state); + test_scenario::return_to_sender(scenario, owner_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = hello_token::foreign_contracts::E_INVALID_CONTRACT_ADDRESS)] + public fun cannot_replace_foreign_contract_zero_address() { + let (creator, _) = people(); + let (my_scenario, _) = set_up(creator); + let scenario = &mut my_scenario; + + // Create zero address variable. + let target_contract = @0x0; + + // Fetch the Hello Token state object and owner capability. + let state = test_scenario::take_shared(scenario); + let owner_cap = + test_scenario::take_from_sender(scenario); + + // Register the emitter. + hello_token::owner::register_foreign_contract( + &owner_cap, + &mut state, + TEST_TARGET_CHAIN, + TEST_TARGET_CONTRACT, + ); + + // Verify that the contract was registered correctly. + { + let is_registered = + hello_token::state::contract_registered(&state, TEST_TARGET_CHAIN); + assert!(is_registered, 0); + + let registered_contract = + hello_token::state::foreign_contract_address( + &state, + TEST_TARGET_CHAIN + ); + assert!( + external_address::to_address( + registered_contract + ) == TEST_TARGET_CONTRACT, + 0 + ); + }; + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Attempt to replace the registered emitter with the zero address. + hello_token::owner::register_foreign_contract( + &owner_cap, + &mut state, + TEST_TARGET_CHAIN, + target_contract + ); + + // Bye bye. + test_scenario::return_shared(state); + test_scenario::return_to_sender(scenario, owner_cap); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + public fun update_relayer_fee() { + let (creator, _) = people(); + let (my_scenario, _) = set_up(creator); + let scenario = &mut my_scenario; + + // Set the test fee and fee precision variables. + let test_fee: u64 = 500000; // 5% + let test_precision: u64 = 10000000; + assert!( + test_precision != TEST_RELAYER_FEE_PRECISION && + test_fee != TEST_RELAYER_FEE, + 0 + ); + + // Fetch the Hello Token state object and owner capability. + let state = test_scenario::take_shared(scenario); + let owner_cap = + test_scenario::take_from_sender(scenario); + + // Verify the initial state. + { + let fee_value = hello_token::state::fee_value(&state); + let fee_precision = hello_token::state::fee_precision(&state); + assert!( + fee_precision == TEST_RELAYER_FEE_PRECISION && + fee_value == TEST_RELAYER_FEE, + 0 + ); + }; + + // Update the relayer fee. + hello_token::owner::update_relayer_fee( + &owner_cap, + &mut state, + test_fee, + test_precision + ); + + // Verify that the state was updated correctly. + { + let fee_value = hello_token::state::fee_value(&state); + let fee_precision = hello_token::state::fee_precision(&state); + assert!( + fee_precision == test_precision && + fee_value == test_fee, + 0 + ); + }; + + // Bye bye. + test_scenario::return_shared(state); + test_scenario::return_to_sender(scenario, owner_cap); + + // Done. + test_scenario::end(my_scenario); + } + + // Utility functions. + + /// Returns two unique test addresses. + public fun people(): (address, address) { + (@0x9f082e1bE326e8863BAc818F0c08ae28a8D47C99, @0x1337) + } + + /// This function sets up the test scenario Hello Token by initializing + /// the Wormhole, Token Bridge and Hello Token contracts. + public fun set_up(creator: address): (Scenario, TransactionEffects) { + let my_scenario = test_scenario::begin(@0x0); + let scenario = &mut my_scenario; + + // Set up Wormhole and the Token Bridge. + { + token_bridge_scenario::set_up_wormhole_and_token_bridge(scenario, 100); + + // Ignore effects. + test_scenario::next_tx(scenario, creator); + }; + + // Set up the Hello Token contract. + let upgrade_cap; + { + upgrade_cap = owner::init_test_only(test_scenario::ctx(scenario)); + + // Proceed. + test_scenario::next_tx(scenario, creator); + }; + + // Register a test emitter on the Token Bridge. + { + let state = test_scenario::take_shared(scenario); + register_chain::register_new_emitter_test_only( + &mut state, + 2, // Ethereum chain ID + external_address::from_address(@0x3ee18B2214AFF97000D974cf647E7C347E8fa585), + ); + + // Proceed. + test_scenario::next_tx(scenario, creator); + + // Return the goods. + test_scenario::return_shared(state); + }; + + // Create the Hello Token shared state object and destory the upgrade cap. + { + let owner_cap = + test_scenario::take_from_sender(scenario); + let wormhole_state = + test_scenario::take_shared(scenario); + + owner::create_state( + &mut owner_cap, + upgrade_cap, + &mut wormhole_state, + TEST_RELAYER_FEE, + TEST_RELAYER_FEE_PRECISION, + test_scenario::ctx(scenario) + ); + + // Bye bye. + test_scenario::return_to_sender( + scenario, + owner_cap + ); + test_scenario::return_shared(wormhole_state); + }; + + let effects = test_scenario::next_tx(scenario, creator); + (my_scenario, effects) + } +} diff --git a/sui/contracts/hello_token/sources/state.move b/sui/contracts/hello_token/sources/state.move new file mode 100644 index 0000000..771499b --- /dev/null +++ b/sui/contracts/hello_token/sources/state.move @@ -0,0 +1,125 @@ +/// This module implements the global state variables for Hello Token. +/// The `State` object is used to perform anything that requires access +/// to data that defines the Hello Token contract. +module hello_token::state { + // Sui dependencies. + use sui::object::{Self, UID}; + use sui::tx_context::{TxContext}; + use sui::table::{Self, Table}; + + // Wormhole dependencies. + use wormhole::emitter::{Self, EmitterCap}; + use wormhole::external_address::{ExternalAddress}; + use wormhole::state::{State as WormholeState}; + + // Hello Token dependencies. + use hello_token::foreign_contracts::{Self}; + use hello_token::relayer_fee::{Self, RelayerFee}; + + // Modules that are allowed to mutate `State`. + friend hello_token::owner; + friend hello_token::transfer; + + // Errors. + const E_INVALID_CHAIN: u64 = 0; + const E_INVALID_CONTRACT_ADDRESS: u64 = 1; + const E_CONTRACT_DOES_NOT_EXIST: u64 = 2; + + /// Object that holds this contract's state. Foreign contracts are + /// stored as dynamic object fields of `State`. + struct State has key, store { + id: UID, + + /// Hello Token owned emitter capability. + emitter_cap: EmitterCap, + + /// Stores relayer fee and precision. + relayer_fee: RelayerFee, + + /// Foreign contract registry. + foreign_contracts: Table, + } + + /// Creates new `State` object. The `emitter_cap` and `relayer_fee` + /// objects are also created. This method should only be executed from the + /// `owner::create_state` method. + public(friend) fun new( + wormhole_state: &WormholeState, + relayer_fee: u64, + relayer_fee_precision: u64, + ctx: &mut TxContext + ): State { + // Create state object. + let state = State { + id: object::new(ctx), + emitter_cap: emitter::new(wormhole_state, ctx), + relayer_fee: relayer_fee::new(relayer_fee, relayer_fee_precision), + foreign_contracts: table::new(ctx) + }; + + // Done. + state + } + + /// This method registers a foreign contract address. The owner can + /// also replace an existing foreign contract for a specified chain ID. + public(friend) fun register_foreign_contract( + self: &mut State, + chain: u16, + contract_address: ExternalAddress, + ) { + if (contract_registered(self, chain)) { + foreign_contracts::update( + &mut self.foreign_contracts, + chain, + contract_address + ); + } else { + foreign_contracts::add( + &mut self.foreign_contracts, + chain, + contract_address, + ); + } + } + + /// Updates the relayer fee and the relayer fee precision. + public(friend) fun update_relayer_fee( + self: &mut State, + relayer_fee: u64, + relayer_fee_precision: u64 + ) { + relayer_fee::update( + &mut self.relayer_fee, + relayer_fee, + relayer_fee_precision + ); + } + + // Getters. + + public(friend) fun emitter_cap(self: &State): &EmitterCap { + &self.emitter_cap + } + + public fun get_relayer_fee(self: &State, amount: u64): u64 { + relayer_fee::compute(&self.relayer_fee, amount) + } + + public fun contract_registered(self: &State, chain: u16): bool { + table::contains(&self.foreign_contracts, chain) + } + + public fun foreign_contract_address(self: &State, chain: u16): ExternalAddress { + assert!(contract_registered(self, chain), E_CONTRACT_DOES_NOT_EXIST); + *table::borrow(&self.foreign_contracts, chain) + } + + public fun fee_value(self: &State): u64 { + relayer_fee::value(&self.relayer_fee) + } + + public fun fee_precision(self: &State): u64 { + relayer_fee::precision(&self.relayer_fee) + } +} diff --git a/sui/contracts/hello_token/sources/test/dummy_message.move b/sui/contracts/hello_token/sources/test/dummy_message.move new file mode 100644 index 0000000..8c268eb --- /dev/null +++ b/sui/contracts/hello_token/sources/test/dummy_message.move @@ -0,0 +1,58 @@ +#[test_only] +module hello_token::dummy_message { + public fun encoded_transfer_coin_8(): (vector, u64) { + // let decimals = 8; + // let expected_amount = 69420; + // let expected_token_address = 0xe4d0bcbdc026b98a242f13e2761601107c90de400f0c24cdafea526abf201c26; // COIN_8 Metadata ID + // let expected_token_chain = 21; + // let expected_recipient = external_address::from_address(@0xbeef); + // let expected_recipient_chain = 21; + // let expected_relayer_fee = 0; + ( + x"010000000001008f14218929a3cb2b7f08aa3505bd90c31352fe33b575985d7134570995f1726d153089147061f9209d5329774915a5b3cdcbb536f85f49996d4e423f59afcaab01645bb8ac0000000000020000000000000000000000003ee18b2214aff97000d974cf647e7c347e8fa585000000000000000001030000000000000000000000000000000000000000000000000000000000010f2ce4d0bcbdc026b98a242f13e2761601107c90de400f0c24cdafea526abf201c260015a80dc5b12f68ff8278c4eb48917aaa3572dde5420c19f8b74e0099eb13ed1a070015000000000000000000000000000000000000000000000000000000000000beef010000000000000000000000009f082e1be326e8863bac818f0c08ae28a8d47c99", + 69420 // Transfer amount. + ) + } + + public fun encoded_transfer_coin_8_minimum_amount(): (vector, u64) { + // let decimals = 8; + // let expected_amount = 1; + // let expected_token_address = 0xe4d0bcbdc026b98a242f13e2761601107c90de400f0c24cdafea526abf201c26; // COIN_8 Metadata ID + // let expected_token_chain = 21; + // let expected_recipient = external_address::from_address(@0xbeef); + // let expected_recipient_chain = 21; + // let expected_relayer_fee = 0; + ( + x"01000000000100c6ee5a08b979bd7342878d7829a349ff536c31ea15b4949bf698984d1aa2c350429bcf0014ec58803cedbee2d90436d6ecbda557233049e32cd13115e72559e100645bd4930000000000020000000000000000000000003ee18b2214aff97000d974cf647e7c347e8fa585000000000000000001030000000000000000000000000000000000000000000000000000000000000001e4d0bcbdc026b98a242f13e2761601107c90de400f0c24cdafea526abf201c260015a80dc5b12f68ff8278c4eb48917aaa3572dde5420c19f8b74e0099eb13ed1a070015000000000000000000000000000000000000000000000000000000000000beef010000000000000000000000009f082e1be326e8863bac818f0c08ae28a8d47c99", + 1 // Transfer amount. + ) + } + + public fun encoded_transfer_coin_8_maximum_amount(): (vector, u64) { + // let decimals = 8; + // let expected_amount = 18446744073709551614; + // let expected_token_address = 0xe4d0bcbdc026b98a242f13e2761601107c90de400f0c24cdafea526abf201c26; // COIN_8 Metadata ID + // let expected_token_chain = 21; + // let expected_recipient = external_address::from_address(@0xbeef); + // let expected_recipient_chain = 21; + // let expected_relayer_fee = 0; + ( + x"0100000000010009e35cfac391bdf90033a3705d556762dbf25d4838d91c227d8d2e4f536ada0e7044047a095da0fc773e433f2fe0d0509dcfd8103ec2d19a09e8578746633db600645c0a710000000000020000000000000000000000003ee18b2214aff97000d974cf647e7c347e8fa58500000000000000000103000000000000000000000000000000000000000000000000fffffffffffffffee4d0bcbdc026b98a242f13e2761601107c90de400f0c24cdafea526abf201c260015a80dc5b12f68ff8278c4eb48917aaa3572dde5420c19f8b74e0099eb13ed1a070015000000000000000000000000000000000000000000000000000000000000beef010000000000000000000000009f082e1be326e8863bac818f0c08ae28a8d47c99", + 18446744073709551614 // Transfer amount. + ) + } + + public fun encoded_transfer_coin_8_invalid_sender(): (vector, u64) { + // let decimals = 8; + // let expected_amount = 42069; + // let expected_token_address = 0xe4d0bcbdc026b98a242f13e2761601107c90de400f0c24cdafea526abf201c26; // COIN_8 Metadata ID + // let expected_token_chain = 21; + // let expected_recipient = external_address::from_address(@0x69); + // let expected_recipient_chain = 21; + // let expected_relayer_fee = 0; + ( + x"0100000000010014a6d43fb807942464d48ec02589a65f2ecb57f30bdc36b51a32a54840b8efa4582327a1be859d96628e42fee21b5edd16e0c37e073d129f1d60207312fc857f00645c14120000000000020000000000000000000000003ee18b2214aff97000d974cf647e7c347e8fa58500000000000000000103000000000000000000000000000000000000000000000000000000000000a455e4d0bcbdc026b98a242f13e2761601107c90de400f0c24cdafea526abf201c260015a80dc5b12f68ff8278c4eb48917aaa3572dde5420c19f8b74e0099eb13ed1a0700150000000000000000000000000000000000000000000000000000000000000069010000000000000000000000009f082e1be326e8863bac818f0c08ae28a8d47c99", + 42069 // Transfer amount. + ) + } +} diff --git a/sui/contracts/hello_token/sources/transfer.move b/sui/contracts/hello_token/sources/transfer.move new file mode 100644 index 0000000..c027732 --- /dev/null +++ b/sui/contracts/hello_token/sources/transfer.move @@ -0,0 +1,1365 @@ +/// This contract uses Wormhole's Token Bridge contract to send tokens +/// cross chain with an aribtrary message payload. +module hello_token::transfer { + // Sui dependencies. + use sui::coin::{Self, Coin}; + use sui::pay::{Self}; + use sui::transfer::{Self}; + use sui::tx_context::{Self, TxContext}; + + // Token Bridge dependencies. + use token_bridge::normalized_amount::{from_raw, to_raw}; + use token_bridge::token_registry::{Self, VerifiedAsset}; + use token_bridge::coin_utils::{Self}; + use token_bridge::transfer_with_payload::{Self}; + use token_bridge::transfer_tokens_with_payload::{ + prepare_transfer, + TransferTicket + }; + use token_bridge::complete_transfer_with_payload::{ + Self as bridge, + RedeemerReceipt + }; + + // Wormhole dependencies. + use wormhole::external_address::{Self}; + + // Hello Token dependencies. + use hello_token::message::{Self}; + use hello_token::state::{Self, State}; + + // Errors. + const E_INVALID_TARGET_RECIPIENT: u64 = 0; + const E_UNREGISTERED_FOREIGN_CONTRACT: u64 = 1; + const E_INSUFFICIENT_AMOUNT: u64 = 2; + + /// Transfers specified coins to any registered Hello Token contract by + /// invoking the `prepare_transfer` method on the Wormhole + /// Token Bridge contract. `prepare_transfer` allows the caller + /// to send an arbitrary message payload along with a token transfer. In + /// this case, the arbitrary message includes the transfer recipient's + /// target-chain wallet address. + /// + /// NOTE: Additional steps are required to fully execute + /// the transfer. The Token Bridge `transfer_tokens_with_payload` + /// method must be called from a transaction block using the + /// `TransferTicket` returned by `send_tokens_with_payload`. + public fun send_tokens_with_payload( + t_state: &State, + coins: Coin, + asset_info: VerifiedAsset, + target_chain: u16, + target_recipient: address, + nonce: u32, + ctx: & TxContext + ): TransferTicket { + // Convert `target_recipient` to an `ExternalAddress` and + // confirm that it's not the zero address. + let target_recipient_address = external_address::from_address( + target_recipient + ); + assert!( + external_address::is_nonzero(&target_recipient_address), + E_INVALID_TARGET_RECIPIENT + ); + + // Confirm that the target chain has a registered contract. + assert!( + state::contract_registered(t_state, target_chain), + E_UNREGISTERED_FOREIGN_CONTRACT + ); + + // Fetch the token decimals from the token registry, and cache the token + // amount. + let decimals = token_registry::coin_decimals(&asset_info); + let amount_received = coin::value(&coins); + + // Compute the normalized amount to verify that it's nonzero. + // The Token Bridge peforms the same operation before encoding + // the amount in the `TransferWithPayload` message. + assert!( + to_raw(from_raw(amount_received, decimals), decimals) > 0, + E_INSUFFICIENT_AMOUNT + ); + + // Prepare the transfer on the Token Bridge. + let (prepared_transfer, dust) = prepare_transfer( + state::emitter_cap(t_state), + asset_info, + coins, + target_chain, + external_address::to_bytes( + state::foreign_contract_address( + t_state, + target_chain + ) + ), + message::serialize( + message::new( + target_recipient_address + ) + ), + nonce + ); + + // Return to sender. + coin_utils::return_nonzero(dust, ctx); + + prepared_transfer + } + + /// `redeem_transfer_with_payload` calls Wormhole's Token Bridge Contract + /// to redeem coins transferred from a different blockchain. If the caller + /// is not the recipient, the contract will pay the caller a fee for + /// relaying the transaction. + /// + /// NOTE: To successfully redeem the tokens from the Token Bridge, + /// additional actions must be executed in a transaction block. See + /// the integration tests in `sui/ts/tests/02_hello_token.ts` to see + /// an example. + public fun redeem_transfer_with_payload( + t_state: &State, + receipt: RedeemerReceipt, + ctx: &mut TxContext + ) { + // Complete the transfer on the Token Bridge. This call returns the + // coin object for the amount transferred via the Token Bridge. It + // also returns the chain ID of the message sender. + let (coins, transfer_payload, emitter_chain_id) = + bridge::redeem_coin( + state::emitter_cap(t_state), + receipt + ); + + // Check that the emitter is a registered contract. + assert!( + state::foreign_contract_address( + t_state, + emitter_chain_id + ) == transfer_with_payload::sender(&transfer_payload), + E_UNREGISTERED_FOREIGN_CONTRACT + ); + + // Parse the additional payload. + let msg = message::deserialize( + transfer_with_payload::payload(&transfer_payload) + ); + + // Parse the recipient field. + let recipient = external_address::to_address( + message::recipient(&msg) + ); + + // Calculate the relayer fee. + let relayer_fee = state::get_relayer_fee( + t_state, + coin::value(&coins) + ); + + // If the relayer fee is nonzero and the user is not self redeeming, + // split the coins object and transfer the relayer fee to the signer. + if (relayer_fee > 0 && recipient != tx_context::sender(ctx)) { + pay::split(&mut coins, relayer_fee, ctx); + }; + + // Send the coins to the target recipient. + transfer::public_transfer(coins, recipient); + } +} + +#[test_only] +module hello_token::transfer_tests { + // Standard lib. + use std::vector; + + // Sui dependencies. + use sui::sui::SUI; + use sui::test_scenario::{Self, Scenario, TransactionEffects}; + use sui::coin::{Self, Coin, CoinMetadata}; + use sui::object::{Self}; + use sui::transfer::{Self as native_transfer}; + use sui::tx_context::{TxContext}; + + // Hello Token dependencies. + use hello_token::owner::{Self, OwnerCap}; + use hello_token::transfer::{Self}; + use hello_token::state::{State}; + use hello_token::owner_tests::{set_up, people}; + use hello_token::dummy_message::{Self}; + + // Wormhole dependencies. + use wormhole::state::{State as WormholeState}; + use wormhole::publish_message::{Self}; + use wormhole::wormhole_scenario::{parse_and_verify_vaa}; + + // Token Bridge dependencies. + use token_bridge::state::{ + Self as bridge_state, + State as TokenBridgeState + }; + use token_bridge::attest_token::{Self}; + use token_bridge::complete_transfer_with_payload::{authorize_transfer}; + use token_bridge::transfer_tokens_with_payload::{ + transfer_tokens_with_payload + }; + use token_bridge::token_bridge_scenario::{Self}; + use token_bridge::vaa::{Self}; + + // Example coins. + use example_coins::coin_8::{Self, COIN_8}; + use example_coins::coin_10::{Self, COIN_10}; + + // Updating these constants will alter the results of the tests. + const TEST_FOREIGN_CHAIN: u16 = 2; + const TEST_FOREIGN_CONTRACT: address = @0xbeef; + + #[test] + /// This test transfers tokens with an additional payload using example coin 8 + /// (which has 8 decimals). + public fun send_tokens_with_payload_coin_8() { + let (sender, _) = people(); + let (my_scenario, _) = set_up(sender); + let scenario = &mut my_scenario; + + // Fetch state objects. + let hello_token_state = + test_scenario::take_shared(scenario); + let bridge_state = + test_scenario::take_shared(scenario); + let wormhole_state = + test_scenario::take_shared(scenario); + + // Test variables. + let test_amount = 42069000; + let nonce = 0; + let target_chain = 2; + let recipient = @0xbeFA429d57cD18b7F8A4d91A2da9AB4AF05d0FBe; + + // Mint token 8, fetch the metadata and store the object ID for later. + let (test_coin, test_metadata) = mint_coin_8( + test_amount, + test_scenario::ctx(scenario) + ); + test_scenario::next_tx(scenario, sender); + + // Run the test setup. + transfer_setup( + &mut hello_token_state, + &mut bridge_state, + test_metadata, + sender, + scenario + ); + test_scenario::next_tx(scenario, sender); + + // Fetch the asset info. + let asset_info = + bridge_state::verified_asset(&bridge_state); + + // Send a test transfer. + let prepared_transfer = transfer::send_tokens_with_payload( + &hello_token_state, + test_coin, + asset_info, + target_chain, + recipient, + nonce, + test_scenario::ctx(scenario) + ); + + // Call `transfer_tokens_with_payload`. + let prepared_message = transfer_tokens_with_payload( + &mut bridge_state, + prepared_transfer + ); + + // Return the goods. + test_scenario::return_shared(hello_token_state); + test_scenario::return_shared(bridge_state); + test_scenario::return_shared(wormhole_state); + publish_message::destroy(prepared_message); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// This test transfers tokens with an additional payload using example coin 10 + /// (which has 10 decimals). Since this coin has 10 decimals, the Token Bridge + /// will truncate the transfer amount. This test confirms that the Hello Token + /// contract correctly sends the dust back to the caller. + public fun send_tokens_with_payload_coin_10() { + let (sender, _) = people(); + let (my_scenario, _) = set_up(sender); + let scenario = &mut my_scenario; + + // Fetch state objects. + let hello_token_state = + test_scenario::take_shared(scenario); + let bridge_state = + test_scenario::take_shared(scenario); + let wormhole_state = + test_scenario::take_shared(scenario); + + // Test variables. + let test_amount = 69042000069; + let expected_token_dust = 69; + let nonce = 0; + let target_chain = 2; + let recipient = @0xbeFA429d57cD18b7F8A4d91A2da9AB4AF05d0FBe; + + // Mint token 10, fetch the metadata and store the object ID for later. + let (test_coin, test_metadata) = mint_coin_10( + test_amount, + test_scenario::ctx(scenario) + ); + test_scenario::next_tx(scenario, sender); + + // Store test coin ID for later use. + let test_coin_id = object::id(&test_coin); + + // Run the test setup. + transfer_setup( + &mut hello_token_state, + &mut bridge_state, + test_metadata, + sender, + scenario + ); + test_scenario::next_tx(scenario, sender); + + // Fetch the asset info. + let asset_info = + bridge_state::verified_asset(&bridge_state); + + // Send a test transfer. + let prepared_transfer = transfer::send_tokens_with_payload( + &hello_token_state, + test_coin, + asset_info, + target_chain, + recipient, + nonce, + test_scenario::ctx(scenario) + ); + + // Call `transfer_tokens_with_payload`. + let prepared_message = transfer_tokens_with_payload( + &mut bridge_state, + prepared_transfer + ); + + // Proceed. + test_scenario::next_tx(scenario, sender); + + // Fetch the dust coin object. + let dust_object = + test_scenario::take_from_sender_by_id>( + scenario, + test_coin_id + ); + + // Confirm that the value of the token is non-zero. + assert!(coin::value(&dust_object) == expected_token_dust, 0); + + // Bye bye. + test_scenario::return_to_sender(scenario, dust_object); + + // Return the goods. + test_scenario::return_shared(hello_token_state); + test_scenario::return_shared(bridge_state); + test_scenario::return_shared(wormhole_state); + publish_message::destroy(prepared_message); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = 2, location=transfer)] + /// This test confirms that the Hello Token contract will revert if the + /// amount is not large enough to transfer through the Token Bridge. The + /// `test_amount` variable is intentially set to an amount which will be + /// converted to zero when the Token Bridge truncates the amount. + public fun cannot_send_tokens_with_payload_coin_10_insufficient_amount() { + let (sender, _) = people(); + let (my_scenario, _) = set_up(sender); + let scenario = &mut my_scenario; + + // Fetch state objects. + let hello_token_state = + test_scenario::take_shared(scenario); + let bridge_state = + test_scenario::take_shared(scenario); + let wormhole_state = + test_scenario::take_shared(scenario); + + // Test variables. + let test_amount = 19; // Amount that will be truncated to zero. + let nonce = 0; + let target_chain = 2; + let recipient = @0xbeFA429d57cD18b7F8A4d91A2da9AB4AF05d0FBe; + + // Mint token 10, fetch the metadata and store the object ID for later. + let (test_coin, test_metadata) = mint_coin_10( + test_amount, + test_scenario::ctx(scenario) + ); + test_scenario::next_tx(scenario, sender); + + // Run the test setup. + transfer_setup( + &mut hello_token_state, + &mut bridge_state, + test_metadata, + sender, + scenario + ); + test_scenario::next_tx(scenario, sender); + + // Fetch the asset info. + let asset_info = + bridge_state::verified_asset(&bridge_state); + + // Send a test transfer. + let prepared_transfer = transfer::send_tokens_with_payload( + &hello_token_state, + test_coin, + asset_info, + target_chain, + recipient, + nonce, + test_scenario::ctx(scenario) + ); + + // Call `transfer_tokens_with_payload`. + let prepared_message = transfer_tokens_with_payload( + &mut bridge_state, + prepared_transfer + ); + + // Return the goods. + test_scenario::return_shared(hello_token_state); + test_scenario::return_shared(bridge_state); + test_scenario::return_shared(wormhole_state); + publish_message::destroy(prepared_message); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = 1, location=transfer)] + /// This test confirms that the Hello Token contract will revert + /// if the specified target chain is not registered. + public fun cannot_send_tokens_with_payload_contract_not_registered() { + let (sender, _) = people(); + let (my_scenario, _) = set_up(sender); + let scenario = &mut my_scenario; + + // Fetch state objects. + let hello_token_state = + test_scenario::take_shared(scenario); + let bridge_state = + test_scenario::take_shared(scenario); + let wormhole_state = + test_scenario::take_shared(scenario); + + // Test variables. + let test_amount = 69042000069; + let nonce = 0; + + // NOTE: Only chain 2 is registered in `transfer_setup`. We set + // the `target_chain` to 20 on purpose to force an error. + let target_chain = 20; + let recipient = @0xbeFA429d57cD18b7F8A4d91A2da9AB4AF05d0FBe; + + // Mint token 10, fetch the metadata and store the object ID for later. + let (test_coin, test_metadata) = mint_coin_10( + test_amount, + test_scenario::ctx(scenario) + ); + test_scenario::next_tx(scenario, sender); + + // Run the test setup. + transfer_setup( + &mut hello_token_state, + &mut bridge_state, + test_metadata, + sender, + scenario + ); + test_scenario::next_tx(scenario, sender); + + // Fetch the asset info. + let asset_info = + bridge_state::verified_asset(&bridge_state); + + // Send a test transfer. + let prepared_transfer = transfer::send_tokens_with_payload( + &hello_token_state, + test_coin, + asset_info, + target_chain, + recipient, + nonce, + test_scenario::ctx(scenario) + ); + + // Call `transfer_tokens_with_payload`. + let prepared_message = transfer_tokens_with_payload( + &mut bridge_state, + prepared_transfer + ); + + // Return the goods. + test_scenario::return_shared(hello_token_state); + test_scenario::return_shared(bridge_state); + test_scenario::return_shared(wormhole_state); + publish_message::destroy(prepared_message); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = 0, location=transfer)] + /// This test confirms that the Hello Token contract will revert + /// if the specified `recipient` is the zero address. + public fun cannot_send_tokens_with_payload_invalid_recipient() { + let (sender, _) = people(); + let (my_scenario, _) = set_up(sender); + let scenario = &mut my_scenario; + + // Fetch state objects. + let hello_token_state = + test_scenario::take_shared(scenario); + let bridge_state = + test_scenario::take_shared(scenario); + let wormhole_state = + test_scenario::take_shared(scenario); + + // Test variables. + let test_amount = 69042000069; + let nonce = 0; + let target_chain = 2; + + // NOTE: We set the recipient address to the zero address + // on purpose to force an error. + let recipient = @0x0; + + // Mint token 10, fetch the metadata and store the object ID for later. + let (test_coin, test_metadata) = mint_coin_10( + test_amount, + test_scenario::ctx(scenario) + ); + test_scenario::next_tx(scenario, sender); + + // Run the test setup. + transfer_setup( + &mut hello_token_state, + &mut bridge_state, + test_metadata, + sender, + scenario + ); + test_scenario::next_tx(scenario, sender); + + // Fetch the asset info. + let asset_info = + bridge_state::verified_asset(&bridge_state); + + // Send a test transfer. + let prepared_transfer = transfer::send_tokens_with_payload( + &hello_token_state, + test_coin, + asset_info, + target_chain, + recipient, + nonce, + test_scenario::ctx(scenario) + ); + + // Call `transfer_tokens_with_payload`. + let prepared_message = transfer_tokens_with_payload( + &mut bridge_state, + prepared_transfer + ); + + // Return the goods. + test_scenario::return_shared(hello_token_state); + test_scenario::return_shared(bridge_state); + test_scenario::return_shared(wormhole_state); + publish_message::destroy(prepared_message); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// This test confirms that the Hello Token contract correctly + /// redeems token transfers and does not pay a relayer fee + /// since the redeeming wallet is the encoded recipient. + public fun redeem_transfer_with_payload_self_redemption() { + let (recipient, _) = people(); + let (my_scenario, _) = set_up(recipient); + let scenario = &mut my_scenario; + + // Fetch VAA and transfer amount. + let (signed_transfer_message, test_amount) = + dummy_message::encoded_transfer_coin_8(); + + // Fetch state objects. + let hello_token_state = + test_scenario::take_shared(scenario); + let bridge_state = + test_scenario::take_shared(scenario); + + // Perform test setup. + { + // Fetch the coin metadata. + let (test_coin, test_metadata) = mint_coin_8( + test_amount, + test_scenario::ctx(scenario) + ); + test_scenario::next_tx(scenario, recipient); + + // Run the test setup. + transfer_setup( + &mut hello_token_state, + &mut bridge_state, + test_metadata, + recipient, + scenario + ); + test_scenario::next_tx(scenario, recipient); + + // Deposit tokens into the bridge, so we can use the Hello Token + // contract to complete the transfer. + token_bridge_scenario::deposit_native( + &mut bridge_state, + test_amount + ); + test_scenario::next_tx(scenario, recipient); + + // Transfer the coin to the zero address since it's not used. + native_transfer::public_transfer(test_coin, @0x0); + }; + + // Verify the VAA. + let verified_vaa = parse_and_verify_vaa( + scenario, + signed_transfer_message + ); + let parsed = vaa::verify_only_once(&mut bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, recipient); + + // Execute authorize_transfer. + let receipt = + authorize_transfer( + &mut bridge_state, + parsed, + test_scenario::ctx(scenario) + ); + + // Redeem the transfer on the Hello Token contract. + transfer::redeem_transfer_with_payload( + &hello_token_state, + receipt, + test_scenario::ctx(scenario) + ); + + // Proceed. + let effects = test_scenario::next_tx(scenario, recipient); + + // Verify results. + { + // Store created object IDs. + let created_ids = test_scenario::created(&effects); + assert!(vector::length(&created_ids) == 1, 0); + + let token_object = + test_scenario::take_from_sender>(scenario); + + // Validate the object's value. + assert!(coin::value(&token_object) == test_amount, 0); + + // Bye bye. + test_scenario::return_to_sender(scenario, token_object); + }; + + // Return the goods. + test_scenario::return_shared(hello_token_state); + test_scenario::return_shared(bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// This test confirms that the Hello Token contract correctly + /// redeems token transfers and pays a relayer fee to the caller + /// for redeeming the transaction. + public fun redeem_transfer_with_payload_with_relayer() { + let (recipient, relayer) = people(); + let (my_scenario, _) = set_up(recipient); + let scenario = &mut my_scenario; + + // Fetch VAA, transfer amount and expected relayer payout. + let (signed_transfer_message, test_amount) = + dummy_message::encoded_transfer_coin_8(); + let expected_relayer_fee = 2920; // 4.2069% * test_amount + + // Fetch state objects. + let hello_token_state = + test_scenario::take_shared(scenario); + let bridge_state = + test_scenario::take_shared(scenario); + + // Perform test setup. + { + // Fetch the coin metadata. + let (test_coin, test_metadata) = mint_coin_8( + test_amount, + test_scenario::ctx(scenario) + ); + + // Change context to the recipient for test setup. + test_scenario::next_tx(scenario, recipient); + + // Run the test setup. + transfer_setup( + &mut hello_token_state, + &mut bridge_state, + test_metadata, + recipient, + scenario + ); + + // Change context to the relayer. + test_scenario::next_tx(scenario, relayer); + + // Deposit tokens into the bridge, so we can use the Hello Token + // contract to complete the transfer. + token_bridge_scenario::deposit_native( + &mut bridge_state, + test_amount + ); + test_scenario::next_tx(scenario, relayer); + + // Transfer the coin to the zero address since it's not used. + native_transfer::public_transfer(test_coin, @0x0); + }; + + // Verify the VAA. + let verified_vaa = parse_and_verify_vaa( + scenario, + signed_transfer_message + ); + let parsed = vaa::verify_only_once(&mut bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, relayer); + + // Execute authorize_transfer. + let receipt = + authorize_transfer( + &mut bridge_state, + parsed, + test_scenario::ctx(scenario) + ); + + // Redeem the transfer on the Hello Token contract. + transfer::redeem_transfer_with_payload( + &hello_token_state, + receipt, + test_scenario::ctx(scenario) + ); + + // Proceed. + let effects = test_scenario::next_tx(scenario, relayer); + + // Verify results. + { + // Store created object IDs. + let created_ids = test_scenario::created(&effects); + assert!(vector::length(&created_ids) == 2, 0); + + // Fetch the relayer fee object by id. + let relayer_fee_obj = + test_scenario::take_from_sender_by_id>( + scenario, + *vector::borrow(&created_ids, 0) + ); + + // Validate the relayer fee object's value. + assert!(coin::value(&relayer_fee_obj) == expected_relayer_fee, 0); + + // Bye bye. + test_scenario::return_to_sender(scenario, relayer_fee_obj); + + // Proceed with the test and change context to recipient. + test_scenario::next_tx(scenario, recipient); + + // Fetch the transferred object by id. + let transferred_coin_obj = + test_scenario::take_from_sender_by_id>( + scenario, + *vector::borrow(&created_ids, 1) + ); + + // Validate the relayer fee object's value. + let expected_amount = test_amount - expected_relayer_fee; + assert!(coin::value(&transferred_coin_obj) == expected_amount, 0); + + // Bye bye. + test_scenario::return_to_sender(scenario, transferred_coin_obj); + }; + + // Return the goods. + test_scenario::return_shared(hello_token_state); + test_scenario::return_shared(bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// This test confirms that the Hello Token contract correctly + /// redeems token transfers for the minimum amount. The contract + /// should not pay any relayer fees since the amount is so small + /// and the relayer fee calculation rounds down to zero. + public fun redeem_transfer_with_payload_with_relayer_minimum_amount() { + let (recipient, relayer) = people(); + let (my_scenario, _) = set_up(recipient); + let scenario = &mut my_scenario; + + // Fetch VAA, transfer amount and expected relayer payout. + let (signed_transfer_message, test_amount) = + dummy_message::encoded_transfer_coin_8_minimum_amount(); + + // Fetch state objects. + let hello_token_state = + test_scenario::take_shared(scenario); + let bridge_state = + test_scenario::take_shared(scenario); + + // Perform test setup. + { + // Fetch the coin metadata. + let (test_coin, test_metadata) = mint_coin_8( + test_amount, + test_scenario::ctx(scenario) + ); + + // Change context to the recipient for test setup. + test_scenario::next_tx(scenario, recipient); + + // Run the test setup. + transfer_setup( + &mut hello_token_state, + &mut bridge_state, + test_metadata, + recipient, + scenario + ); + + // Change context to the relayer. + test_scenario::next_tx(scenario, relayer); + + // Deposit tokens into the bridge, so we can use the Hello Token + // contract to complete the transfer. + token_bridge_scenario::deposit_native( + &mut bridge_state, + test_amount + ); + test_scenario::next_tx(scenario, relayer); + + // Transfer the coin to the zero address since it's not used. + native_transfer::public_transfer(test_coin, @0x0); + }; + + // Verify the VAA. + let verified_vaa = parse_and_verify_vaa( + scenario, + signed_transfer_message + ); + let parsed = vaa::verify_only_once(&mut bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, relayer); + + // Execute authorize_transfer. + let receipt = + authorize_transfer( + &mut bridge_state, + parsed, + test_scenario::ctx(scenario) + ); + + // Redeem the transfer on the Hello Token contract. + transfer::redeem_transfer_with_payload( + &hello_token_state, + receipt, + test_scenario::ctx(scenario) + ); + + // Proceed. + let effects = test_scenario::next_tx(scenario, relayer); + + // Verify results. + { + // Store created object IDs. Only one coin object should be + // created, since the relayer fee was zero and nothing was + // paid to the relayer. + let created_ids = test_scenario::created(&effects); + assert!(vector::length(&created_ids) == 1, 0); + + // Proceed with the test and change context to recipient. + test_scenario::next_tx(scenario, recipient); + + // Fetch the transferred object by id. + let transferred_coin_obj = + test_scenario::take_from_sender_by_id>( + scenario, + *vector::borrow(&created_ids, 0) + ); + + // Validate the recipient object's value. + assert!(coin::value(&transferred_coin_obj) == test_amount, 0); + + // Bye bye. + test_scenario::return_to_sender(scenario, transferred_coin_obj); + }; + + // Return the goods. + test_scenario::return_shared(hello_token_state); + test_scenario::return_shared(bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// This test confirms that the Hello Token contract correctly handles + /// transfers for the maximum amount (type(uint64).max) when the caller + /// is the encoded recipient. + public fun redeem_transfer_with_payload_self_redemption_maximum_amount() { + let (recipient, _) = people(); + let (my_scenario, _) = set_up(recipient); + let scenario = &mut my_scenario; + + // Fetch VAA and transfer amount. + let (signed_transfer_message, test_amount) = + dummy_message::encoded_transfer_coin_8_maximum_amount(); + + // Fetch state objects. + let hello_token_state = + test_scenario::take_shared(scenario); + let bridge_state = + test_scenario::take_shared(scenario); + + // Perform test setup. + { + // Fetch the coin metadata. + let (test_coin, test_metadata) = mint_coin_8( + test_amount, + test_scenario::ctx(scenario) + ); + test_scenario::next_tx(scenario, recipient); + + // Run the test setup. + transfer_setup( + &mut hello_token_state, + &mut bridge_state, + test_metadata, + recipient, + scenario + ); + test_scenario::next_tx(scenario, recipient); + + // Deposit tokens into the bridge, so we can use the Hello Token + // contract to complete the transfer. + token_bridge_scenario::deposit_native( + &mut bridge_state, + test_amount + ); + test_scenario::next_tx(scenario, recipient); + + // Transfer the coin to the zero address since it's not used. + native_transfer::public_transfer(test_coin, @0x0); + }; + + // Verify the VAA. + let verified_vaa = parse_and_verify_vaa( + scenario, + signed_transfer_message + ); + let parsed = vaa::verify_only_once(&mut bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, recipient); + + // Execute authorize_transfer. + let receipt = + authorize_transfer( + &mut bridge_state, + parsed, + test_scenario::ctx(scenario) + ); + + // Redeem the transfer on the Hello Token contract. + transfer::redeem_transfer_with_payload( + &hello_token_state, + receipt, + test_scenario::ctx(scenario) + ); + + // Proceed. + let effects = test_scenario::next_tx(scenario, recipient); + + // Verify results. + { + // Store created object IDs. + let created_ids = test_scenario::created(&effects); + assert!(vector::length(&created_ids) == 1, 0); + + let token_object = + test_scenario::take_from_sender>(scenario); + + // Validate the object's value. + assert!(coin::value(&token_object) == test_amount, 0); + + // Bye bye. + test_scenario::return_to_sender(scenario, token_object); + }; + + // Return the goods. + test_scenario::return_shared(hello_token_state); + test_scenario::return_shared(bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + /// This test confirms that the Hello Token contract correctly handles + /// transfers for the maximum amount (type(uint64).max) when the caller + /// is not the encoded recipient. The contract should correctly pay the + /// caller the expected relayer fee. + public fun redeem_transfer_with_payload_with_relayer_maximum_amount() { + let (recipient, relayer) = people(); + let (my_scenario, _) = set_up(recipient); + let scenario = &mut my_scenario; + + // Fetch VAA, transfer amount and expected relayer payout. + let (signed_transfer_message, test_amount) = + dummy_message::encoded_transfer_coin_8_maximum_amount(); + let expected_relayer_fee = 776036076436887126; // 4.2069% * test_amount + + // Fetch state objects. + let hello_token_state = + test_scenario::take_shared(scenario); + let bridge_state = + test_scenario::take_shared(scenario); + + // Perform test setup. + { + // Fetch the coin metadata. + let (test_coin, test_metadata) = mint_coin_8( + test_amount, + test_scenario::ctx(scenario) + ); + + // Change context to the recipient for test setup. + test_scenario::next_tx(scenario, recipient); + + // Run the test setup. + transfer_setup( + &mut hello_token_state, + &mut bridge_state, + test_metadata, + recipient, + scenario + ); + + // Change context to the relayer. + test_scenario::next_tx(scenario, relayer); + + // Deposit tokens into the bridge, so we can use the Hello Token + // contract to complete the transfer. + token_bridge_scenario::deposit_native( + &mut bridge_state, + test_amount + ); + test_scenario::next_tx(scenario, relayer); + + // Transfer the coin to the zero address since it's not used. + native_transfer::public_transfer(test_coin, @0x0); + }; + + // Verify the VAA. + let verified_vaa = parse_and_verify_vaa( + scenario, + signed_transfer_message + ); + let parsed = vaa::verify_only_once(&mut bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, relayer); + + // Execute authorize_transfer. + let receipt = + authorize_transfer( + &mut bridge_state, + parsed, + test_scenario::ctx(scenario) + ); + + // Redeem the transfer on the Hello Token contract. + transfer::redeem_transfer_with_payload( + &hello_token_state, + receipt, + test_scenario::ctx(scenario) + ); + + // Proceed. + let effects = test_scenario::next_tx(scenario, relayer); + + // Verify results. + { + // Store created object IDs. + let created_ids = test_scenario::created(&effects); + assert!(vector::length(&created_ids) == 2, 0); + + // Fetch the relayer fee object by id. + let relayer_fee_obj = + test_scenario::take_from_sender_by_id>( + scenario, + *vector::borrow(&created_ids, 0) + ); + + // Validate the relayer fee object's value. + assert!(coin::value(&relayer_fee_obj) == expected_relayer_fee, 0); + + // Bye bye. + test_scenario::return_to_sender(scenario, relayer_fee_obj); + + // Proceed with the test and change context to recipient. + test_scenario::next_tx(scenario, recipient); + + // Fetch the transferred object by id. + let transferred_coin_obj = + test_scenario::take_from_sender_by_id>( + scenario, + *vector::borrow(&created_ids, 1) + ); + + // Validate the relayer fee object's value. + let expected_amount = test_amount - expected_relayer_fee; + assert!(coin::value(&transferred_coin_obj) == expected_amount, 0); + + // Bye bye. + test_scenario::return_to_sender(scenario, transferred_coin_obj); + }; + + // Return the goods. + test_scenario::return_shared(hello_token_state); + test_scenario::return_shared(bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + #[test] + #[expected_failure(abort_code = 1, location=transfer)] + /// This test confirms that the Hello Token contract will revert + /// if the sender of the transfer message is not the registered + /// contract for the specified chain ID. + public fun cannot_redeem_transfer_with_payload_unknown_sender() { + let (recipient, _) = people(); + let (my_scenario, _) = set_up(recipient); + let scenario = &mut my_scenario; + + // Fetch VAA and transfer amount. + let (signed_transfer_message, test_amount) = + dummy_message::encoded_transfer_coin_8_invalid_sender(); + + // Fetch state objects. + let hello_token_state = + test_scenario::take_shared(scenario); + let bridge_state = + test_scenario::take_shared(scenario); + + // Perform test setup. + { + // Fetch the coin metadata. + let (test_coin, test_metadata) = mint_coin_8( + test_amount, + test_scenario::ctx(scenario) + ); + test_scenario::next_tx(scenario, recipient); + + // Run the test setup. + transfer_setup( + &mut hello_token_state, + &mut bridge_state, + test_metadata, + recipient, + scenario + ); + test_scenario::next_tx(scenario, recipient); + + // Deposit tokens into the bridge, so we can use the Hello Token + // contract to complete the transfer. + token_bridge_scenario::deposit_native( + &mut bridge_state, + test_amount + ); + test_scenario::next_tx(scenario, recipient); + + // Transfer the coin to the zero address since it's not used. + native_transfer::public_transfer(test_coin, @0x0); + }; + + // Verify the VAA. + let verified_vaa = parse_and_verify_vaa( + scenario, + signed_transfer_message + ); + let parsed = vaa::verify_only_once(&mut bridge_state, verified_vaa); + + // Ignore effects. + test_scenario::next_tx(scenario, recipient); + + // Execute authorize_transfer. + let receipt = + authorize_transfer( + &mut bridge_state, + parsed, + test_scenario::ctx(scenario) + ); + + // Redeem the transfer on the Hello Token contract. + transfer::redeem_transfer_with_payload( + &hello_token_state, + receipt, + test_scenario::ctx(scenario) + ); + + // Return the goods. + test_scenario::return_shared(hello_token_state); + test_scenario::return_shared(bridge_state); + + // Done. + test_scenario::end(my_scenario); + } + + /// Utilities. + + public fun mint_coin_8( + amount: u64, + ctx: &mut TxContext + ): (Coin, CoinMetadata) { + // Initialize token 8. + let (treasury_cap, metadata) = coin_8::create_coin_test_only(ctx); + + // Mint tokens. + let test_coin = coin::mint( + &mut treasury_cap, + amount, + ctx + ); + + // Balance check the new coin object. + assert!(coin::value(&test_coin) == amount, 0); + + // Bye bye. + native_transfer::public_transfer(treasury_cap, @0x0); + + // Return. + (test_coin, metadata) + } + + public fun mint_coin_10( + amount: u64, + ctx: &mut TxContext + ): (Coin, CoinMetadata) { + // Initialize token 10. + let (treasury_cap, metadata) = coin_10::create_coin_test_only(ctx); + + // Mint tokens. + let test_coin = coin::mint( + &mut treasury_cap, + amount, + ctx + ); + + // Balance check the new coin object. + assert!(coin::value(&test_coin) == amount, 0); + + // Bye bye. + native_transfer::public_transfer(treasury_cap, @0x0); + + // Return. + (test_coin, metadata) + } + + public fun mint_sui(amount: u64, ctx: &mut TxContext): Coin { + // Mint SUI tokens. + let sui_coin = sui::coin::mint_for_testing( + amount, + ctx + ); + assert!(coin::value(&sui_coin) == amount, 0); + + sui_coin + } + + public fun transfer_setup( + hello_token_state: &mut State, + bridge_state: &mut TokenBridgeState, + coin_meta: CoinMetadata, + sender: address, + scenario: &mut Scenario + ): TransactionEffects { + // Cache the owner_cap. + let owner_cap = + test_scenario::take_from_sender(scenario); + + // Register the target contract. + { + owner::register_foreign_contract( + &owner_cap, + hello_token_state, + TEST_FOREIGN_CHAIN, + TEST_FOREIGN_CONTRACT + ); + + // Proceed. + test_scenario::next_tx(scenario, sender); + }; + + // Attest token. + { + let prepared_message = attest_token::attest_token( + bridge_state, + &coin_meta, + 0, // nonce + ); + + // Proceed. + test_scenario::next_tx(scenario, sender); + native_transfer::public_transfer(coin_meta, @0x0); + publish_message::destroy(prepared_message); + }; + + // Return owner cap. + test_scenario::return_to_sender(scenario, owner_cap); + + let effects = test_scenario::next_tx(scenario, sender); + (effects) + } +} diff --git a/sui/dependencies/scripts/deploy.sh b/sui/dependencies/scripts/deploy.sh new file mode 100644 index 0000000..288aa92 --- /dev/null +++ b/sui/dependencies/scripts/deploy.sh @@ -0,0 +1,89 @@ +#!/usr/bin/env bash + +set -euo pipefail + +# Help message +function usage() { +cat <&2 +Deploy and initialize Sui core bridge and token bridge contracts to the +specified network. Additionally deploys an example messaging contract in +devnet. + Usage: $(basename "$0") [options] + Positional args: + Network to deploy to (devnet, testnet, mainnet) + Options: + -k, --private-key Use given key to sign transactions + -h, --help Show this help message +EOF +exit 1 +} + +# If positional args are missing, print help message and exit +if [ $# -lt 1 ]; then + usage +fi + +# Default values +PRIVATE_KEY_ARG= + +# Set network +NETWORK=$1 || usage +shift + +# Set guardian address +if [ "$NETWORK" = mainnet ]; then + echo "Mainnet not supported yet" + exit 1 +elif [ "$NETWORK" = testnet ]; then + echo "Testnet not supported yet" + exit 1 +elif [ "$NETWORK" = devnet ]; then + GUARDIAN_ADDR=befa429d57cd18b7f8a4d91a2da9ab4af05d0fbe +else + usage +fi + +# Parse short/long flags +while [[ $# -gt 0 ]]; do + case "$1" in + -k|--private-key) + PRIVATE_KEY_ARG="-k $2" + shift 2 + ;; + -h|--help) + usage + exit 0 + ;; + *) + echo "Unknown option: $1" + usage + exit 1 + ;; + esac +done + +# Assumes this script is in a sibling directory to contract dirs +DIRNAME=$(dirname "$0") +WORMHOLE_PATH=$(realpath "$DIRNAME"/../wormhole) +TOKEN_BRIDGE_PATH=$(realpath "$DIRNAME"/../token_bridge) + +echo -e "[1/4] Publishing core bridge contracts..." +WORMHOLE_PUBLISH_OUTPUT=$($(echo worm sui deploy "$WORMHOLE_PATH" -n "$NETWORK" "$PRIVATE_KEY_ARG")) +echo "$WORMHOLE_PUBLISH_OUTPUT" + +echo -e "\n[2/4] Initializing core bridge..." +WORMHOLE_PACKAGE_ID=$(echo "$WORMHOLE_PUBLISH_OUTPUT" | grep -oP 'Published to +\K.*') +WORMHOLE_INIT_OUTPUT=$($(echo worm sui init-wormhole -n "$NETWORK" --initial-guardian "$GUARDIAN_ADDR" -p "$WORMHOLE_PACKAGE_ID" "$PRIVATE_KEY_ARG")) +WORMHOLE_STATE_OBJECT_ID=$(echo "$WORMHOLE_INIT_OUTPUT" | grep -oP 'Wormhole state object ID +\K.*') +echo "$WORMHOLE_INIT_OUTPUT" + +echo -e "\n[3/4] Publishing token bridge contracts..." +TOKEN_BRIDGE_PUBLISH_OUTPUT=$($(echo worm sui deploy "$TOKEN_BRIDGE_PATH" -n "$NETWORK" "$PRIVATE_KEY_ARG")) +echo "$TOKEN_BRIDGE_PUBLISH_OUTPUT" + +echo -e "\n[4/4] Initializing token bridge..." +TOKEN_BRIDGE_PACKAGE_ID=$(echo "$TOKEN_BRIDGE_PUBLISH_OUTPUT" | grep -oP 'Published to +\K.*') +TOKEN_BRIDGE_INIT_OUTPUT=$($(echo worm sui init-token-bridge -n "$NETWORK" -p "$TOKEN_BRIDGE_PACKAGE_ID" --wormhole-state "$WORMHOLE_STATE_OBJECT_ID" -"$PRIVATE_KEY_ARG")) +echo "$TOKEN_BRIDGE_INIT_OUTPUT" + +echo -e "\nDeployments successful!" diff --git a/sui/env/testing.env b/sui/env/testing.env new file mode 100644 index 0000000..da26821 --- /dev/null +++ b/sui/env/testing.env @@ -0,0 +1,23 @@ +### Wormhole +export TESTING_WORMHOLE_ID=0xb960add402229a8367f698f33728e9295cb1e66519c29093d044ea3914305b59 +export TESTING_WORMHOLE_STATE_ID=0x045a01c8334815326b98cde5f26e108803dddcac316b2f3edfe392280e6311d1 + +### Token Bridge +export TESTING_TOKEN_BRIDGE_ID=0x577c711679f9285935053c2bc8dcaf768c417fa0db4f174f5e1a9407f9610da2 +export TESTING_TOKEN_BRIDGE_STATE_ID=0x50f8144533c17382e12641043f3febf479407cdd00e9bb3ed5a7d62cdcfdde2b + +### Example Coins +export TESTING_EXAMPLE_COINS_ID=0xbfa8d913ccc41ca8522c2f0b3567097316a70ae0eb00bb290d08f9c9047056ce +export TESTING_COIN_10_TREASURY_ID=0x150748f30672d3248e8e066a110aa4016ef7164ee34b2891a894676bc74f89f5 +export TESTING_COIN_8_TREASURY_ID=0xa60073e03641dbe2fc56b75bd4df5fa121643c0df1c4d8b636205baf534bf4d9 + +### Hello Token +export TESTING_HELLO_TOKEN_ID=0xefcd8d7c6548c5d137278a640f3467628886ecf78dc9b5025875000af3895e88 +export TESTING_HELLO_TOKEN_OWNER_CAPABILITY_ID=0xf73fdcda3b270f9a13fedad84d14a49a3da6c6bdae72a0f7627edcb87885bb64 +export TESTING_HELLO_TOKEN_UPGRADE_CAP_ID=0xa72ab60caf8e4302a421e1dcd471ed678b85bdffc5d22b7e28198636fc72db4f + +### Guardian +export TESTING_DEVNET_GUARDIAN=cfb12303a19cde580bb4dd771639b0d26bc68353645571a8cff516ab2ee113a0 + +### Sui Metadata Id +export SUI_METADATA_ID=0x6b99da33ef72fde46e0da375e2d575af46ad80b1f00b50a73c14551a3f98f627 diff --git a/sui/package.json b/sui/package.json new file mode 100644 index 0000000..32627ab --- /dev/null +++ b/sui/package.json @@ -0,0 +1,29 @@ +{ + "name": "token-bridge-relayer", + "version": "0.1.0", + "license": "ISC", + "scripts": { + "deploy": "ts-node ts/scripts/deploy-contract.ts -p", + "lint:fix": "prettier */*.js \"*/**/*{.js,.ts}\" -w", + "lint": "prettier */*.js \"*/**/*{.js,.ts}\" --check" + }, + "dependencies": { + "@certusone/wormhole-sdk": "^0.9.16", + "@mysten/sui.js": "^0.32.2", + "ethers": "^5.7.2", + "ts-node": "^10.9.1", + "yaml": "^2.2.1", + "yargs": "^17.6.2" + }, + "devDependencies": { + "@types/chai": "^4.3.4", + "@types/mocha": "^10.0.1", + "@types/node": "^18.11.18", + "@types/yargs": "^17.0.20", + "chai": "^4.3.7", + "mocha": "^10.2.0", + "prettier": "^2.8.2", + "ts-mocha": "^10.0.0", + "typescript": "^4.9.4" + } +} diff --git a/sui/shell-scripts/fetch_wormhole_contracts.sh b/sui/shell-scripts/fetch_wormhole_contracts.sh new file mode 100644 index 0000000..f4dca2e --- /dev/null +++ b/sui/shell-scripts/fetch_wormhole_contracts.sh @@ -0,0 +1,43 @@ +#!/bin/bash + +### Navigate back to the root of this program directory +cd $(dirname $0)/.. + +### This directory should already exist, but attempting to make +### it just in case. +mkdir -p dependencies +cd dependencies + +### Is wormhole built already? Bail out if so +WORMHOLE_BYTECODE=./Wormhole/bytecode_modules/*.mv +TOKEN_BRIDGE_BYTECODE=./TokenBridge/bytecode_modules/*.mv +ls $WORMHOLE_BYTECODE $TOKEN_BRIDGE_BYTECODE > /dev/null 2>&1 +if [ $? -eq 0 ]; then + exit 0; +fi + +### Clone the repo (main branch) +echo "fetching Sui programs from wormhole repo" +git clone \ + --depth 1 \ + --branch main \ + --filter=blob:none \ + --sparse \ + https://github.com/wormhole-foundation/wormhole \ + tmp-wormhole > /dev/null 2>&1 +cd tmp-wormhole + +### Checkout sui directory and move that to this program directory +git sparse-checkout set sui > /dev/null 2>&1 + +### Move source +cd .. +mv -fn tmp-wormhole/sui/wormhole . +mv -fn tmp-wormhole/sui/token_bridge . +rm -rf tmp-wormhole + +sed -i 's/wormhole = \"0x0\"/wormhole = "_"/g' wormhole/Move.toml +sed -i 's/token_bridge = \"0x0\"/token_bridge = "_"/g' token_bridge/Move.toml + +### Done +exit 0 diff --git a/sui/shell-scripts/run_integration_tests.sh b/sui/shell-scripts/run_integration_tests.sh new file mode 100644 index 0000000..4e10fd0 --- /dev/null +++ b/sui/shell-scripts/run_integration_tests.sh @@ -0,0 +1,47 @@ +#/bin/bash + +pgrep -f sui-test-validator > /dev/null +if [ $? -eq 0 ]; then + echo "sui-test-validator already running" + exit 1; +fi + +DEPENDENCIES_DIR=$(pwd)/dependencies +TEST_DIR=$(dirname $0)/../ts/tests +SUI_CONFIG=$TEST_DIR/sui_config + +### Remove databases generated by localnet +rm -rf $SUI_CONFIG/*_db + +### Start local node +echo "Starting local validator." +sui start \ + --network.config $TEST_DIR/sui_config/network.yaml > /dev/null 2>&1 & + +sleep 1 + +DEVNET_KEY=ACMS4emBUzUD0vcYoiSM2Z8i2qs4MMrKeFRZY3L/pXYK + +echo "deploying wormhole contracts to localnet" +bash $DEPENDENCIES_DIR/scripts/deploy.sh devnet \ + -k $DEVNET_KEY + +echo "deploying example coins" +worm sui deploy \ + $DEPENDENCIES_DIR/../contracts/example_coins \ + -n devnet -k $DEVNET_KEY -d true + +## deploy relayer contracts +echo "deploying hello token" +worm sui deploy \ + $DEPENDENCIES_DIR/../contracts/hello_token \ + -n devnet -k $DEVNET_KEY -d true + +## run contract tests here +npx ts-mocha -t 1000000 $TEST_DIR/0[0-9]*.ts + +# nuke +pkill sui + +# remove databases generated by localnet +rm -rf $SUI_CONFIG/*_db diff --git a/sui/ts/src/consts.ts b/sui/ts/src/consts.ts new file mode 100644 index 0000000..3a1b46e --- /dev/null +++ b/sui/ts/src/consts.ts @@ -0,0 +1,67 @@ +// wallets +export const WALLET_PRIVATE_KEY = Buffer.from( + "AEDorSqM3nYmNeja26rmaddyyZ4dMpSoEYWxT71+AWbD", + "base64" +).subarray(1); +export const RELAYER_PRIVATE_KEY = Buffer.from( + "AJaQFexEWr4WS7UxY2yEBNZLTI0FCkI8QNWm23bUNA10", + "base64" +).subarray(1); +export const RAW_CREATOR_KEY = "ACMS4emBUzUD0vcYoiSM2Z8i2qs4MMrKeFRZY3L/pXYK"; +export const CREATOR_PRIVATE_KEY = Buffer.from( + RAW_CREATOR_KEY, + "base64" +).subarray(1); + +// wormhole +export const WORMHOLE_ID = process.env.TESTING_WORMHOLE_ID!; +export const WORMHOLE_STATE_ID = process.env.TESTING_WORMHOLE_STATE_ID!; +export const WORMHOLE_FEE = "0"; + +// token bridge +export const TOKEN_BRIDGE_ID = process.env.TESTING_TOKEN_BRIDGE_ID!; +export const TOKEN_BRIDGE_STATE_ID = process.env.TESTING_TOKEN_BRIDGE_STATE_ID!; + +// hello token +export const HELLO_TOKEN_ID = process.env.TESTING_HELLO_TOKEN_ID!; +export const HELLO_TOKEN_OWNER_CAP_ID = + process.env.TESTING_HELLO_TOKEN_OWNER_CAPABILITY_ID!; +export const HELLO_TOKEN_UPGRADE_CAP_ID = + process.env.TESTING_HELLO_TOKEN_UPGRADE_CAP_ID!; + +// guardian signer +export const GUARDIAN_PRIVATE_KEY = + "cfb12303a19cde580bb4dd771639b0d26bc68353645571a8cff516ab2ee113a0"; + +// example coins +export const EXAMPLE_COINS_ID = process.env.TESTING_EXAMPLE_COINS_ID!; + +// 8-decimal coin (COIN_8) +export const COIN_8_TREASURY_ID = process.env.TESTING_COIN_8_TREASURY_ID!; +export const COIN_8_TYPE = `${EXAMPLE_COINS_ID}::coin_8::COIN_8`; + +// 10-decimal coin (COIN_10) +export const COIN_10_TREASURY_ID = process.env.TESTING_COIN_10_TREASURY_ID!; +export const COIN_10_TYPE = `${EXAMPLE_COINS_ID}::coin_10::COIN_10`; + +// SUI coin. +export const SUI_TYPE = "0x2::sui::SUI"; +export const SUI_METADATA_ID = process.env.SUI_METADATA_ID!; + +// wrapped weth +export const WRAPPED_WETH_COIN_TYPE = + process.env.TESTING_WRAPPED_WETH_COIN_TYPE!; +export const WRAPPED_WETH_ID = process.env.TESTING_WRAPPED_WETH_ID!; + +// testing +export const FUZZ_TEST_ITERATIONS = 64; + +// foreign +export const ETHEREUM_TOKEN_BRIDGE_ADDRESS = + "0x3ee18B2214AFF97000D974cf647E7C347E8fa585"; +export const WETH_ID = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"; + +// governance +export const GOVERNANCE_CHAIN = "1"; +export const GOVERNANCE_EMITTER_ID = + "0000000000000000000000000000000000000000000000000000000000000004"; diff --git a/sui/ts/src/index.ts b/sui/ts/src/index.ts new file mode 100644 index 0000000..178cd64 --- /dev/null +++ b/sui/ts/src/index.ts @@ -0,0 +1 @@ +export * from "./utils"; diff --git a/sui/ts/src/utils.ts b/sui/ts/src/utils.ts new file mode 100644 index 0000000..469068b --- /dev/null +++ b/sui/ts/src/utils.ts @@ -0,0 +1,197 @@ +import {JsonRpcProvider} from "@mysten/sui.js"; +import {WORMHOLE_STATE_ID} from "./consts"; + +export async function getWormholeFee(provider: JsonRpcProvider) { + // Fetch the wormhole state fields. + const fields = await getObjectFields(provider, WORMHOLE_STATE_ID); + + if (fields === null) { + Promise.reject("State object not found."); + } + + // Cache wormhole fee. + return fields!.fee_collector.fields.fee_amount; +} + +interface HelloTokenMessage { + payloadType: number; + recipient: string; +} + +export function parseHelloTokenPayload(payload: Buffer): HelloTokenMessage { + let relay: HelloTokenMessage = {} as HelloTokenMessage; + + // Parse the additional payload. + relay.payloadType = payload.readUint8(133); + relay.recipient = "0x" + payload.subarray(134, 166).toString("hex"); + return relay; +} + +export function calculateRelayerFee( + transferAmount: number, + state: any +): number { + const fee = state!.relayer_fee.fields; + const value = Number(fee.value); + const precision = Number(fee.precision); + + return Math.floor((value * transferAmount) / precision); +} + +export function createHelloTokenPayload(recipient: string): string { + const payloadType = "0x01"; + + if (recipient.substring(0, 2) != "0x" || recipient.length != 66) { + throw Error("Invalid recipient parameter"); + } + + return payloadType + recipient.substring(2); +} + +export function getWormholeEvents(result: any) { + if ("events" in result) { + let wormholeEvents = []; + for (const event of result.events!) { + if (event.type.includes("WormholeMessage")) { + wormholeEvents.push(event); + } + } + return wormholeEvents; + } else { + return null; + } +} + +export async function getObjectFields( + provider: JsonRpcProvider, + objectId: string +) { + // Fetch object. + const result = await provider.getObject({ + id: objectId, + options: {showContent: true}, + }); + + if ( + typeof result.data!.content !== "string" && + "fields" in result.data!.content! + ) { + return result.data!.content.fields; + } else { + return null; + } +} + +export async function getDynamicObjectFields( + provider: JsonRpcProvider, + parentId: string, + childName: any +) { + const dynamicObjectFieldInfo = await provider + .getDynamicFieldObject({ + parentId: parentId, + name: childName, + }) + .then((result) => { + if ( + typeof result.data!.content !== "string" && + "content" in result.data! && + "fields" in result.data!.content! + ) { + return result.data?.content; + } else { + return null; + } + }); + + if (dynamicObjectFieldInfo === null) { + return Promise.reject("invalid dynamic object field"); + } + + return dynamicObjectFieldInfo; +} + +export async function getForeignContractsTable( + provider: JsonRpcProvider, + objectId: string +) { + // Fetch the table's keys + const keys = await provider + .getDynamicFields({parentId: objectId}) + .then((result) => result.data); + + if (keys.length == 0) { + return Promise.reject("dynamic field not found"); + } + + // Create array of key value pairs + const tableTuples = await Promise.all( + keys.map(async (key) => { + // Fetch the value + const valueObject = await getObjectFields(provider, key.objectId); + return [key.name.value, valueObject!.value]; + }) + ); + + return tableTuples; +} + +export async function getCoinWithHighestBalance( + provider: JsonRpcProvider, + walletAddress: string, + coinType: string +) { + const coins = await provider + .getCoins({ + owner: walletAddress, + coinType: coinType, + }) + .then((result) => result.data); + + if (coins.length == 0) { + return Promise.reject("no coins with balance found"); + } + + let balanceMax = 0; + let index = 0; + + // Find the coin with the highest balance. + for (let i = 0; i < coins.length; i++) { + let balance = parseInt(coins[i].balance); + if (balance > balanceMax) { + balanceMax = balance; + index = i; + } + } + + return coins[index]; +} + +export function tokenBridgeNormalizeAmount( + amount: number, + decimals: number +): number { + if (decimals > 8) { + amount = amount / 10 ** (decimals - 8); + } + return Math.floor(amount); +} + +export function getBalanceChangeFromTransaction( + wallet: string, + coinType: string, + balanceChanges: any +): number { + const result = balanceChanges.filter( + (result: any) => + result.owner.AddressOwner == wallet && + (result.coinType == coinType || + result.coinType.includes(coinType.substring(3))) + ); + + if (result.length != 1) { + throw Error("could not find balance"); + } + + return Math.abs(parseInt(result[0].amount)); +} diff --git a/sui/ts/tests/00_environment.ts b/sui/ts/tests/00_environment.ts new file mode 100644 index 0000000..0a4b688 --- /dev/null +++ b/sui/ts/tests/00_environment.ts @@ -0,0 +1,419 @@ +import {expect} from "chai"; +import {ethers} from "ethers"; +import * as mock from "@certusone/wormhole-sdk/lib/cjs/mock"; +import { + ETHEREUM_TOKEN_BRIDGE_ADDRESS, + GOVERNANCE_EMITTER_ID, + GUARDIAN_PRIVATE_KEY, + WALLET_PRIVATE_KEY, + TOKEN_BRIDGE_ID, + RELAYER_PRIVATE_KEY, + CREATOR_PRIVATE_KEY, + WORMHOLE_STATE_ID, + TOKEN_BRIDGE_STATE_ID, + COIN_10_TREASURY_ID, + COIN_8_TREASURY_ID, + COIN_8_TYPE, + COIN_10_TYPE, + SUI_TYPE, + SUI_METADATA_ID, + WORMHOLE_ID, +} from "../src/consts"; +import { + Ed25519Keypair, + JsonRpcProvider, + localnetConnection, + RawSigner, + TransactionBlock, + SUI_CLOCK_OBJECT_ID, +} from "@mysten/sui.js"; +import {getWormholeFee, getObjectFields} from "../src"; + +describe("0: Wormhole", () => { + const provider = new JsonRpcProvider(localnetConnection); + + // User wallet. + const wallet = new RawSigner( + Ed25519Keypair.fromSecretKey(WALLET_PRIVATE_KEY), + provider + ); + + // Relayer wallet. + const relayer = new RawSigner( + Ed25519Keypair.fromSecretKey(RELAYER_PRIVATE_KEY), + provider + ); + + // Deployer wallet. + const creator = new RawSigner( + Ed25519Keypair.fromSecretKey(CREATOR_PRIVATE_KEY), + provider + ); + + // Mock guardians for signing wormhole messages. + const guardians = new mock.MockGuardians(0, [GUARDIAN_PRIVATE_KEY]); + + // for governance actions to modify programs + const governance = new mock.GovernanceEmitter(GOVERNANCE_EMITTER_ID, 20); + + describe("Environment", () => { + it("Variables", () => { + expect(process.env.TESTING_WORMHOLE_ID).is.not.undefined; + expect(process.env.TESTING_WORMHOLE_STATE_ID).is.not.undefined; + expect(process.env.TESTING_TOKEN_BRIDGE_ID).is.not.undefined; + expect(process.env.TESTING_TOKEN_BRIDGE_STATE_ID).is.not.undefined; + expect(process.env.TESTING_EXAMPLE_COINS_ID).is.not.undefined; + expect(process.env.TESTING_COIN_8_TREASURY_ID).is.not.undefined; + expect(process.env.TESTING_COIN_10_TREASURY_ID).is.not.undefined; + }); + }); + + describe("Verify Local Validator", () => { + it("Balance", async () => { + // Balance check wallet. + { + const coinData = await wallet + .getAddress() + .then((address) => + provider.getCoins({owner: address}).then((result) => result.data) + ); + for (const coin of coinData) { + expect(coin.balance).equals("30000000000000000"); + } + } + + // Balance check relayer. + { + const coinData = await relayer + .getAddress() + .then((address) => + provider.getCoins({owner: address}).then((result) => result.data) + ); + for (const coin of coinData) { + expect(coin.balance).equals("30000000000000000"); + } + } + }); + + it("Mint and transfer example coins", async () => { + const walletAddress = await wallet.getAddress(); + + // COIN_10 + { + const metadata = await provider.getCoinMetadata({ + coinType: COIN_10_TYPE, + }); + expect(metadata!.decimals).equals(10); + + // Format the amount based on the coin decimals. + const amount = ethers.utils + .parseUnits("69420", metadata!.decimals) + .add(10) // for outbound transfer later + .toString(); + + // Mint and transfer the coins. + const tx = new TransactionBlock(); + tx.moveCall({ + target: "0x2::coin::mint_and_transfer", + arguments: [ + tx.object(COIN_10_TREASURY_ID), + tx.pure(amount), + tx.pure(walletAddress), + ], + typeArguments: [COIN_10_TYPE], + }); + tx.setGasBudget(50_000); + const result = await creator.signAndExecuteTransactionBlock({ + transactionBlock: tx, + }); + expect(result.digest).is.not.null; + + // Check balance on wallet. + const balance = await provider.getBalance({ + owner: walletAddress, + coinType: COIN_10_TYPE, + }); + expect(balance.coinObjectCount).equals(1); + expect(balance.totalBalance.toString()).equals(amount); + } + + // COIN_8 + { + const metadata = await provider.getCoinMetadata({ + coinType: COIN_8_TYPE, + }); + expect(metadata!.decimals).equals(8); + + // Format the amount based on the coin decimals. + const amount = ethers.utils + .parseUnits("42069", metadata!.decimals) + .add(10) // for outbound transfer later + .toString(); + + // Mint and transfer the coins. + const tx = new TransactionBlock(); + tx.moveCall({ + target: "0x2::coin::mint_and_transfer", + arguments: [ + tx.object(COIN_8_TREASURY_ID), + tx.pure(amount), + tx.pure(walletAddress), + ], + typeArguments: [COIN_8_TYPE], + }); + tx.setGasBudget(50_000); + const result = await creator.signAndExecuteTransactionBlock({ + transactionBlock: tx, + }); + expect(result.digest).is.not.null; + + // Check balance on wallet. + const balance = await provider.getBalance({ + owner: walletAddress, + coinType: COIN_8_TYPE, + }); + expect(balance.coinObjectCount).equals(1); + expect(balance.totalBalance.toString()).equals(amount); + } + }); + + it("Register foreign emitter (Ethereum)", async () => { + // Create an emitter registration VAA. + const message = governance.publishTokenBridgeRegisterChain( + 0, // timestamp + 2, + ETHEREUM_TOKEN_BRIDGE_ADDRESS + ); + const signedWormholeMessage = guardians.addSignatures(message, [0]); + + // Register an emitter from Ethereum on the token bridge. + { + const tx = new TransactionBlock(); + + // Parse and verify the vaa. + const [verifiedVaa] = tx.moveCall({ + target: `${WORMHOLE_ID}::vaa::parse_and_verify`, + arguments: [ + tx.object(WORMHOLE_STATE_ID), + tx.pure(Array.from(signedWormholeMessage)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + // Authorize the governance. + const [decreeTicket] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::register_chain::authorize_governance`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID)], + }); + + // Fetch the governance message. + const [decreeReceipt] = tx.moveCall({ + target: `${WORMHOLE_ID}::governance_message::verify_vaa`, + arguments: [tx.object(WORMHOLE_STATE_ID), verifiedVaa, decreeTicket], + typeArguments: [ + `${TOKEN_BRIDGE_ID}::register_chain::GovernanceWitness`, + ], + }); + + // Register the chain. + tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::register_chain::register_chain`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), decreeReceipt], + }); + tx.setGasBudget(50_000); + const result = await creator.signAndExecuteTransactionBlock({ + transactionBlock: tx, + }); + expect(result.digest).is.not.null; + } + }); + + // Before any coin can be transferred out, it needs to be attested for. + it("Attest native coins", async () => { + // Fetch Sui object to pay wormhole fees with. + const feeAmount = await getWormholeFee(provider); + + // COIN_10 + { + // Coin 10 metadata and nonce. + const metadata = await provider.getCoinMetadata({ + coinType: COIN_10_TYPE, + }); + const nonce = 69; + + // Call `token_bridge::attest_token` on Token Bridge. + const tx = new TransactionBlock(); + const [wormholeFee] = tx.splitCoins(tx.gas, [tx.pure(feeAmount)]); + + // Fetch message ticket. + const [messageTicket] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::attest_token::attest_token`, + arguments: [ + tx.object(TOKEN_BRIDGE_STATE_ID), + tx.object(metadata!.id!), + tx.pure(nonce), + ], + typeArguments: [COIN_10_TYPE], + }); + + // Publish the message. + tx.moveCall({ + target: `${WORMHOLE_ID}::publish_message::publish_message`, + arguments: [ + tx.object(WORMHOLE_STATE_ID), + wormholeFee, + messageTicket, + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + tx.setGasBudget(50_000); + const eventData = await wallet + .signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEvents: true, + }, + }) + .then((result) => { + if ("events" in result && result.events?.length == 1) { + return result.events[0]; + } + + throw new Error("event not found"); + }); + + // Verify that the attest message was published. + expect(eventData.transactionModule).equal("publish_message"); + expect(eventData.parsedJson!.nonce).equals(nonce); + expect(eventData.parsedJson!.sequence).equals("0"); + + // Verify that a token was registered in the token bridge state. + const tokenBridgeState = await getObjectFields( + provider, + TOKEN_BRIDGE_STATE_ID + ); + expect(tokenBridgeState!.token_registry.fields.num_native).equals("1"); + } + + // COIN_8 + { + // Coin 8 metadata and nonce. + const metadata = await provider.getCoinMetadata({ + coinType: COIN_8_TYPE, + }); + const nonce = 420; + + // Call `token_bridge::attest_token` on Token Bridge. + const tx = new TransactionBlock(); + const [wormholeFee] = tx.splitCoins(tx.gas, [tx.pure(feeAmount)]); + + // Fetch message ticket. + const [messageTicket] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::attest_token::attest_token`, + arguments: [ + tx.object(TOKEN_BRIDGE_STATE_ID), + tx.object(metadata!.id!), + tx.pure(nonce), + ], + typeArguments: [COIN_8_TYPE], + }); + + // Publish the message. + tx.moveCall({ + target: `${WORMHOLE_ID}::publish_message::publish_message`, + arguments: [ + tx.object(WORMHOLE_STATE_ID), + wormholeFee, + messageTicket, + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + tx.setGasBudget(50_000); + const eventData = await wallet + .signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEvents: true, + }, + }) + .then((result) => { + if ("events" in result && result.events?.length == 1) { + return result.events[0]; + } + + throw new Error("event not found"); + }); + + // Verify that the attest message was published. + expect(eventData.transactionModule).equal("publish_message"); + expect(eventData.parsedJson!.nonce).equals(nonce); + expect(eventData.parsedJson!.sequence).equals("1"); + + // Verify that a token was registered in the token bridge state. + const tokenBridgeState = await getObjectFields( + provider, + TOKEN_BRIDGE_STATE_ID + ); + expect(tokenBridgeState!.token_registry.fields.num_native).equals("2"); + } + }); + + it("Attest Sui", async () => { + // Fetch Sui object to pay wormhole fees with. + const feeAmount = await getWormholeFee(provider); + const nonce = 420; + + // Call `token_bridge::attest_token` on Token Bridge. + const tx = new TransactionBlock(); + const [wormholeFee] = tx.splitCoins(tx.gas, [tx.pure(feeAmount)]); + + // Fetch message ticket. + const [messageTicket] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::attest_token::attest_token`, + arguments: [ + tx.object(TOKEN_BRIDGE_STATE_ID), + tx.object(SUI_METADATA_ID), + tx.pure(nonce), + ], + typeArguments: [SUI_TYPE], + }); + + // Publish the message. + tx.moveCall({ + target: `${WORMHOLE_ID}::publish_message::publish_message`, + arguments: [ + tx.object(WORMHOLE_STATE_ID), + wormholeFee, + messageTicket, + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + tx.setGasBudget(50_000); + const eventData = await wallet + .signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEvents: true, + }, + }) + .then((result) => { + if ("events" in result && result.events?.length == 1) { + return result.events[0]; + } + throw new Error("event not found"); + }); + + // Verify that the attest message was published. + expect(eventData.transactionModule).equal("publish_message"); + expect(eventData.parsedJson!.nonce).equals(nonce); + expect(eventData.parsedJson!.sequence).equals("2"); + + // Verify that a token was registered in the token bridge state. + const tokenBridgeState = await getObjectFields( + provider, + TOKEN_BRIDGE_STATE_ID + ); + expect(tokenBridgeState!.token_registry.fields.num_native).equals("3"); + }); + }); +}); diff --git a/sui/ts/tests/02_hello_token.ts b/sui/ts/tests/02_hello_token.ts new file mode 100644 index 0000000..762fa1a --- /dev/null +++ b/sui/ts/tests/02_hello_token.ts @@ -0,0 +1,1211 @@ +import {expect} from "chai"; +import {CHAIN_ID_SUI, parseTransferPayload} from "@certusone/wormhole-sdk"; +import * as mock from "@certusone/wormhole-sdk/lib/cjs/mock"; +import { + ETHEREUM_TOKEN_BRIDGE_ADDRESS, + GUARDIAN_PRIVATE_KEY, + WALLET_PRIVATE_KEY, + RELAYER_PRIVATE_KEY, + CREATOR_PRIVATE_KEY, + WORMHOLE_STATE_ID, + TOKEN_BRIDGE_STATE_ID, + HELLO_TOKEN_ID, + HELLO_TOKEN_OWNER_CAP_ID, + HELLO_TOKEN_UPGRADE_CAP_ID, + COIN_8_TYPE, + COIN_10_TYPE, + SUI_TYPE, + WORMHOLE_ID, + TOKEN_BRIDGE_ID, +} from "../src/consts"; +import { + Ed25519Keypair, + JsonRpcProvider, + RawSigner, + localnetConnection, + TransactionBlock, + SUI_CLOCK_OBJECT_ID, +} from "@mysten/sui.js"; +import { + getObjectFields, + getWormholeEvents, + tokenBridgeNormalizeAmount, + getWormholeFee, + getCoinWithHighestBalance, + parseHelloTokenPayload, + createHelloTokenPayload, + getBalanceChangeFromTransaction, + calculateRelayerFee, + getForeignContractsTable, +} from "../src"; + +describe("2: Hello Token", () => { + const provider = new JsonRpcProvider(localnetConnection); + + // User wallet. + const wallet = new RawSigner( + Ed25519Keypair.fromSecretKey(WALLET_PRIVATE_KEY), + provider + ); + + // Relayer wallet. + const relayer = new RawSigner( + Ed25519Keypair.fromSecretKey(RELAYER_PRIVATE_KEY), + provider + ); + + // Deployer wallet. + const creator = new RawSigner( + Ed25519Keypair.fromSecretKey(CREATOR_PRIVATE_KEY), + provider + ); + + // Mock guardians for signing wormhole messages. + const guardians = new mock.MockGuardians(0, [GUARDIAN_PRIVATE_KEY]); + + const localVariables: any = {}; + + describe("Set Up Hello Token Contract", () => { + // Foreign contract. + const foreignChain = 2; + const foreignContractAddress = Buffer.alloc(32, "deadbeef"); + const relayerFee = "50000"; // 5% + const relayerFeePrecision = "1000000"; // 1e6 + + it("Create Hello Token state", async () => { + // Call `owner::create_state` on the Hello Token contract. + const tx = new TransactionBlock(); + tx.moveCall({ + target: `${HELLO_TOKEN_ID}::owner::create_state`, + arguments: [ + tx.object(HELLO_TOKEN_OWNER_CAP_ID), + tx.object(HELLO_TOKEN_UPGRADE_CAP_ID), + tx.object(WORMHOLE_STATE_ID), + tx.pure(relayerFee), + tx.pure(relayerFeePrecision), + ], + }); + + tx.setGasBudget(50_000); + const result = await creator.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: {showObjectChanges: true}, + }); + expect(result.digest).is.not.null; + + // Transaction is successful, so grab state ID. + for (const objectEvent of result.objectChanges!) { + if ( + objectEvent["type"] == "created" && + objectEvent["objectType"].includes("state::State") + ) { + localVariables.stateId = objectEvent["objectId"]; + break; + } + } + + // Fetch the state object fields and validate the setup. + const state = await getObjectFields(provider, localVariables.stateId); + + expect("emitter_cap" in state!).is.true; + expect(state!.relayer_fee.fields.value).equals(relayerFee); + expect(state!.relayer_fee.fields.precision).equals(relayerFeePrecision); + }); + + it("Register foreign contract (Ethereum)", async () => { + expect(localVariables.stateId).is.not.undefined; + const stateId: string = localVariables.stateId; + + // Register a foreign contract on the Hello Token contract. + const tx = new TransactionBlock(); + tx.moveCall({ + target: `${HELLO_TOKEN_ID}::owner::register_foreign_contract`, + arguments: [ + tx.object(HELLO_TOKEN_OWNER_CAP_ID), + tx.object(stateId), + tx.pure(foreignChain), + tx.pure(foreignContractAddress), + ], + }); + + tx.setGasBudget(50_000); + const result = await creator.signAndExecuteTransactionBlock({ + transactionBlock: tx, + }); + expect(result.digest).is.not.null; + + // Fetch the registered contracts table from state. + const state = await getObjectFields(provider, stateId); + const registeredContracts = await getForeignContractsTable( + provider, + state!.foreign_contracts.fields.id.id + ); + expect(registeredContracts).has.length(1); + + // Verify that the contract was registered correctly. + expect(parseInt(registeredContracts![0][0])).to.equal(foreignChain); + expect( + Buffer.from( + registeredContracts![0][1].fields.value.fields.data + ).toString("hex") + ).to.equal(foreignContractAddress.toString("hex")); + }); + }); + + describe("Test Business Logic", () => { + // Mock foreign token bridge. + const ethereumTokenBridge = new mock.MockEthereumTokenBridge( + ETHEREUM_TOKEN_BRIDGE_ADDRESS + ); + + // Foreign HelloToken contract. + const foreignChain = "2"; + const foreignContractAddress = Buffer.alloc(32, "deadbeef"); + + // Transfer nonce. + const nonce = 69; + + describe("Coin 8", () => { + // The `transferAmount` will be transferred outbound in the first test. + // The two following tests will use the `transferAmount` that is + // deposited in the bridge to test complete transfer functionality. + // For both tests to be successful, the following must be true: + // * transferAmount >= mintAmount1 + mintAmount2 + const outboundTransferAmount = "100000000000"; + + it("Send tokens with payload", async () => { + expect(localVariables.stateId).is.not.undefined; + const stateId: string = localVariables.stateId; + + // Fetch wallet address. + const walletAddress = await wallet.getAddress(); + + // Fetch sui coins to pay the wormhole fee. + const feeAmount = await getWormholeFee(provider); + + // Fetch coin 8. + const coin = await getCoinWithHighestBalance( + provider, + walletAddress, + COIN_8_TYPE + ); + + // Balance check before transferring tokens. + const coinBalanceBefore = await provider.getBalance({ + owner: walletAddress, + coinType: COIN_8_TYPE, + }); + + // Start new transaction. + const tx = new TransactionBlock(); + + // Wormhole fee coins. + const [wormholeFee] = tx.splitCoins(tx.gas, [tx.pure(feeAmount)]); + + // Coins to transfer to the target chain. + const [coinsToTransfer] = tx.splitCoins(tx.object(coin.coinObjectId), [ + tx.pure(outboundTransferAmount), + ]); + + // Fetch the asset info. + const [assetInfo] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::state::verified_asset`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID)], + typeArguments: [COIN_8_TYPE], + }); + + // Fetch the transfer ticket. + const [transferTicket] = tx.moveCall({ + target: `${HELLO_TOKEN_ID}::transfer::send_tokens_with_payload`, + arguments: [ + tx.object(stateId), + coinsToTransfer, + assetInfo, + tx.pure(foreignChain), + tx.pure(walletAddress), + tx.pure(nonce), + ], + typeArguments: [COIN_8_TYPE], + }); + + // Transfer the tokens with payload. + const [messageTicket] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::transfer_tokens_with_payload::transfer_tokens_with_payload`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), transferTicket], + typeArguments: [COIN_8_TYPE], + }); + + // Publish the message. + tx.moveCall({ + target: `${WORMHOLE_ID}::publish_message::publish_message`, + arguments: [ + tx.object(WORMHOLE_STATE_ID), + wormholeFee, + messageTicket, + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + tx.setGasBudget(50_000); + const eventData = await wallet.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEvents: true, + }, + }); + + // Fetch wormhole events. + const wormholeEvents = getWormholeEvents(eventData); + expect(wormholeEvents!.length).equals(1); + + // Parse the emitted Wormhole message and verify the payload. + const message = wormholeEvents![0].parsedJson; + expect(message.consistency_level).equal(0); + expect(message.sequence).equals("3"); + expect(message.nonce).equals(nonce); + + // Cache state. + const state = await getObjectFields(provider, stateId); + + // Verify the transfer payload. + { + const transferPayload = await parseTransferPayload( + Buffer.from(message.payload) + ); + expect(transferPayload.amount.toString()).to.equal( + outboundTransferAmount + ); + expect(transferPayload.fromAddress!).equals( + state!.emitter_cap.fields.id.id.substring(2) + ); + expect(transferPayload.originChain).to.equal(CHAIN_ID_SUI); + expect(transferPayload.targetAddress).to.equal( + foreignContractAddress.toString("hex") + ); + expect(transferPayload.targetChain).to.equal(Number(foreignChain)); + } + + // Verify the additional payload. + { + const helloTokenPayload = parseHelloTokenPayload( + Buffer.from(message.payload) + ); + expect(helloTokenPayload.payloadType).equals(1); + expect(helloTokenPayload.recipient).equals(walletAddress); + } + + // Balance check after transferring tokens. + const coinBalanceAfter = await provider.getBalance({ + owner: walletAddress, + coinType: COIN_8_TYPE, + }); + expect( + parseInt(coinBalanceBefore.totalBalance) - + parseInt(coinBalanceAfter.totalBalance) + ).eq(parseInt(outboundTransferAmount)); + }); + + it("Redeem transfer with relayer", async () => { + expect(localVariables.stateId).is.not.undefined; + + // Cache stateId and fetch the state. + const stateId: string = localVariables.stateId; + const state = await getObjectFields(provider, stateId); + + // Save wallet and relayer addresses. + const walletAddress = await wallet.getAddress(); + const relayerAddress = await relayer.getAddress(); + + // Define transfer parameters. + const mintAmount = Math.floor(Number(outboundTransferAmount) / 2); + const recipient = walletAddress; + const tokenAddress = await provider + .getCoinMetadata({ + coinType: COIN_8_TYPE, + }) + .then((result) => result!.id); + + // Create payload. + const payload = createHelloTokenPayload(recipient); + + // Create a transfer tokens with payload message. + const published = ethereumTokenBridge.publishTransferTokensWithPayload( + tokenAddress!.substring(2), + CHAIN_ID_SUI, // tokenChain + BigInt(mintAmount.toString()), + CHAIN_ID_SUI, // recipientChain + state!.emitter_cap.fields.id.id.substring(2), // targetContractAddress + foreignContractAddress, // fromAddress + Buffer.from(payload.substring(2), "hex"), + nonce + ); + + // Sign the transfer message. + const signedWormholeMessage = guardians.addSignatures(published, [0]); + + // Complete the transfer with payload. + let receipt; + { + // Start new transaction. + const tx = new TransactionBlock(); + + // Parse and verify the vaa. + const [parsedVaa] = tx.moveCall({ + target: `${WORMHOLE_ID}::vaa::parse_and_verify`, + arguments: [ + tx.object(WORMHOLE_STATE_ID), + tx.pure(Array.from(signedWormholeMessage)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + // Verify the VAA with the token bridge. + const [tokenBridgeMessage] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::vaa::verify_only_once`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), parsedVaa], + }); + + // Authorize the transfer. + const [redeemerReceipt] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::complete_transfer_with_payload::authorize_transfer`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), tokenBridgeMessage], + typeArguments: [COIN_8_TYPE], + }); + + // Complete the tranfer. + tx.moveCall({ + target: `${HELLO_TOKEN_ID}::transfer::redeem_transfer_with_payload`, + arguments: [tx.object(stateId), redeemerReceipt], + typeArguments: [COIN_8_TYPE], + }); + + tx.setGasBudget(50_000); + receipt = await relayer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEvents: true, + showBalanceChanges: true, + }, + }); + } + + // Fetch balance changes. + const recipientCoinChange = getBalanceChangeFromTransaction( + walletAddress, + COIN_8_TYPE, + receipt.balanceChanges + ); + const relayerCoinChange = getBalanceChangeFromTransaction( + relayerAddress, + COIN_8_TYPE, + receipt.balanceChanges + ); + + // Compute the expected relayer fee to be paid by the contract. + const expectedFee = calculateRelayerFee(mintAmount, state); + + // Validate relayer balance change. + expect(relayerCoinChange).equals(expectedFee); + + // Confirm recipient balance changes. + expect(recipientCoinChange).equals(mintAmount - expectedFee); + }); + + it("Recipient self redeems transfer", async () => { + expect(localVariables.stateId).is.not.undefined; + + // Cache stateId and fetch the state. + const stateId: string = localVariables.stateId; + const state = await getObjectFields(provider, stateId); + + // Save wallet and relayer addresses. + const walletAddress = await wallet.getAddress(); + + // Define transfer parameters. + const mintAmount = Math.floor(Number(outboundTransferAmount) / 2); + const recipient = walletAddress; + const tokenAddress = await provider + .getCoinMetadata({ + coinType: COIN_8_TYPE, + }) + .then((result) => result!.id); + + // Create payload. + const payload = createHelloTokenPayload(recipient); + + // Create a transfer tokens with payload message. + const published = ethereumTokenBridge.publishTransferTokensWithPayload( + tokenAddress!.substring(2), + CHAIN_ID_SUI, // tokenChain + BigInt(mintAmount.toString()), + CHAIN_ID_SUI, // recipientChain + state!.emitter_cap.fields.id.id.substring(2), // targetContractAddress + foreignContractAddress, // fromAddress + Buffer.from(payload.substring(2), "hex"), + nonce + ); + + // Sign the transfer message. + const signedWormholeMessage = guardians.addSignatures(published, [0]); + + // Complete the transfer with payload. + let receipt; + { + // Start new transaction. + const tx = new TransactionBlock(); + + // Parse and verify the vaa. + const [parsedVaa] = tx.moveCall({ + target: `${WORMHOLE_ID}::vaa::parse_and_verify`, + arguments: [ + tx.object(WORMHOLE_STATE_ID), + tx.pure(Array.from(signedWormholeMessage)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + // Verify the VAA with the token bridge. + const [tokenBridgeMessage] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::vaa::verify_only_once`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), parsedVaa], + }); + + // Authorize the transfer. + const [redeemerReceipt] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::complete_transfer_with_payload::authorize_transfer`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), tokenBridgeMessage], + typeArguments: [COIN_8_TYPE], + }); + + // Complete the tranfer. + tx.moveCall({ + target: `${HELLO_TOKEN_ID}::transfer::redeem_transfer_with_payload`, + arguments: [tx.object(stateId), redeemerReceipt], + typeArguments: [COIN_8_TYPE], + }); + + tx.setGasBudget(50_000); + + // NOTE: redeem the transfer with the recipient wallet. + receipt = await wallet.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEvents: true, + showBalanceChanges: true, + }, + }); + } + + // Fetch balance changes. + const recipientCoinChange = getBalanceChangeFromTransaction( + walletAddress, + COIN_8_TYPE, + receipt.balanceChanges + ); + + // Confirm that the recipient received the full mintAmount. + expect(recipientCoinChange).equals(mintAmount); + }); + }); + + describe("Coin 10", () => { + // The `transferAmount` will be transferred outbound in the first test. + // The two following tests will use the `transferAmount` that is + // deposited in the bridge to test complete transfer functionality. + // For both tests to be successful, the following must be true: + // * transferAmount >= mintAmount1 + mintAmount2 + const outboundTransferAmount = "20000000000"; // 2 COIN_10. + const coin10Decimals = 10; + + it("Send tokens with payload", async () => { + expect(localVariables.stateId).is.not.undefined; + const stateId: string = localVariables.stateId; + + // Fetch wallet address. + const walletAddress = await wallet.getAddress(); + + // Fetch sui coins to pay the wormhole fee. + const feeAmount = await getWormholeFee(provider); + + // Fetch coin 10. + const coin = await getCoinWithHighestBalance( + provider, + walletAddress, + COIN_10_TYPE + ); + + // Balance check before transferring tokens. + const coinBalanceBefore = await provider.getBalance({ + owner: walletAddress, + coinType: COIN_10_TYPE, + }); + + // Start new transaction. + const tx = new TransactionBlock(); + + // Wormhole fee coins. + const [wormholeFee] = tx.splitCoins(tx.gas, [tx.pure(feeAmount)]); + + // Coins to transfer to the target chain. + const [coinsToTransfer] = tx.splitCoins(tx.object(coin.coinObjectId), [ + tx.pure(outboundTransferAmount), + ]); + + // Fetch the asset info. + const [assetInfo] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::state::verified_asset`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID)], + typeArguments: [COIN_10_TYPE], + }); + + // Fetch the transfer ticket. + const [transferTicket] = tx.moveCall({ + target: `${HELLO_TOKEN_ID}::transfer::send_tokens_with_payload`, + arguments: [ + tx.object(stateId), + coinsToTransfer, + assetInfo, + tx.pure(foreignChain), + tx.pure(walletAddress), + tx.pure(nonce), + ], + typeArguments: [COIN_10_TYPE], + }); + + // Transfer the tokens with payload. + const [messageTicket] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::transfer_tokens_with_payload::transfer_tokens_with_payload`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), transferTicket], + typeArguments: [COIN_10_TYPE], + }); + + // Publish the message. + tx.moveCall({ + target: `${WORMHOLE_ID}::publish_message::publish_message`, + arguments: [ + tx.object(WORMHOLE_STATE_ID), + wormholeFee, + messageTicket, + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + tx.setGasBudget(50_000); + const eventData = await wallet.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + showBalanceChanges: true, + }, + }); + + // Fetch wormhole events. + const wormholeEvents = getWormholeEvents(eventData); + expect(wormholeEvents!.length).equals(1); + + // Parse the emitted Wormhole message and verify the payload. + const message = wormholeEvents![0].parsedJson; + expect(message.consistency_level).equal(0); + expect(message.sequence).equals("4"); + expect(message.nonce).equals(nonce); + + // Cache state. + const state = await getObjectFields(provider, stateId); + + // Verify the transfer payload. + { + const transferPayload = await parseTransferPayload( + Buffer.from(message.payload) + ); + expect(transferPayload.amount.toString()).to.equal( + tokenBridgeNormalizeAmount( + Number(outboundTransferAmount), + coin10Decimals + ).toString() + ); + expect(transferPayload.fromAddress!).equals( + state!.emitter_cap.fields.id.id.substring(2) + ); + expect(transferPayload.originChain).to.equal(CHAIN_ID_SUI); + expect(transferPayload.targetAddress).to.equal( + foreignContractAddress.toString("hex") + ); + expect(transferPayload.targetChain).to.equal(Number(foreignChain)); + } + + // Verify the additional payload. + { + const helloTokenPayload = parseHelloTokenPayload( + Buffer.from(message.payload) + ); + expect(helloTokenPayload.payloadType).equals(1); + expect(helloTokenPayload.recipient).equals(walletAddress); + } + + // Balance check after transferring tokens. + const coinBalanceAfter = await provider.getBalance({ + owner: walletAddress, + coinType: COIN_10_TYPE, + }); + expect( + parseInt(coinBalanceBefore.totalBalance) - + parseInt(coinBalanceAfter.totalBalance) + ).eq(parseInt(outboundTransferAmount)); + }); + + it("Redeem transfer with relayer", async () => { + expect(localVariables.stateId).is.not.undefined; + + // Cache stateId and fetch the state. + const stateId: string = localVariables.stateId; + const state = await getObjectFields(provider, stateId); + + // Save wallet and relayer addresses. + const walletAddress = await wallet.getAddress(); + const relayerAddress = await relayer.getAddress(); + + // Define transfer parameters. + const mintAmount = Math.floor(Number(outboundTransferAmount) / 2); + const recipient = walletAddress; + const tokenAddress = await provider + .getCoinMetadata({ + coinType: COIN_10_TYPE, + }) + .then((result) => result!.id); + + // Create payload. + const payload = createHelloTokenPayload(recipient); + + // Create a transfer tokens with payload message. + const published = ethereumTokenBridge.publishTransferTokensWithPayload( + tokenAddress!.substring(2), + CHAIN_ID_SUI, // tokenChain + BigInt(tokenBridgeNormalizeAmount(mintAmount, coin10Decimals)), + CHAIN_ID_SUI, // recipientChain + state!.emitter_cap.fields.id.id.substring(2), // targetContractAddress + foreignContractAddress, // fromAddress + Buffer.from(payload.substring(2), "hex"), + nonce + ); + + // Sign the transfer message. + const signedWormholeMessage = guardians.addSignatures(published, [0]); + + // Complete the transfer with payload. + let receipt; + { + // Start new transaction. + const tx = new TransactionBlock(); + + // Parse and verify the vaa. + const [parsedVaa] = tx.moveCall({ + target: `${WORMHOLE_ID}::vaa::parse_and_verify`, + arguments: [ + tx.object(WORMHOLE_STATE_ID), + tx.pure(Array.from(signedWormholeMessage)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + // Verify the VAA with the token bridge. + const [tokenBridgeMessage] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::vaa::verify_only_once`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), parsedVaa], + }); + + // Authorize the transfer. + const [redeemerReceipt] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::complete_transfer_with_payload::authorize_transfer`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), tokenBridgeMessage], + typeArguments: [COIN_10_TYPE], + }); + + // Complete the tranfer. + tx.moveCall({ + target: `${HELLO_TOKEN_ID}::transfer::redeem_transfer_with_payload`, + arguments: [tx.object(stateId), redeemerReceipt], + typeArguments: [COIN_10_TYPE], + }); + + tx.setGasBudget(100_000_000); + receipt = await relayer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEvents: true, + showEffects: true, + showBalanceChanges: true, + }, + }); + } + + // Fetch balance changes. + const recipientCoinChange = getBalanceChangeFromTransaction( + walletAddress, + COIN_10_TYPE, + receipt.balanceChanges + ); + const relayerCoinChange = getBalanceChangeFromTransaction( + relayerAddress, + COIN_10_TYPE, + receipt.balanceChanges + ); + + // Expected relayer fee to be paid by the contract. + const expectedFee = calculateRelayerFee(mintAmount, state); + + // Validate relayer balance change. + expect(relayerCoinChange).equals(expectedFee); + + // Confirm recipient balance changes. + expect(recipientCoinChange).equals(mintAmount - expectedFee); + }); + + it("Recipient self redeems transfer", async () => { + expect(localVariables.stateId).is.not.undefined; + + // Cache stateId and fetch the state. + const stateId: string = localVariables.stateId; + const state = await getObjectFields(provider, stateId); + + // Save wallet and relayer addresses. + const walletAddress = await wallet.getAddress(); + + // Define transfer parameters. + const mintAmount = Math.floor(Number(outboundTransferAmount) / 2); + const recipient = walletAddress; + const tokenAddress = await provider + .getCoinMetadata({ + coinType: COIN_10_TYPE, + }) + .then((result) => result!.id); + + // Create payload. + const payload = createHelloTokenPayload(recipient); + + // Create a transfer tokens with payload message. + const published = ethereumTokenBridge.publishTransferTokensWithPayload( + tokenAddress!.substring(2), + CHAIN_ID_SUI, // tokenChain + BigInt(tokenBridgeNormalizeAmount(mintAmount, coin10Decimals)), + CHAIN_ID_SUI, // recipientChain + state!.emitter_cap.fields.id.id.substring(2), // targetContractAddress + foreignContractAddress, // fromAddress + Buffer.from(payload.substring(2), "hex"), + nonce + ); + + // Sign the transfer message. + const signedWormholeMessage = guardians.addSignatures(published, [0]); + + // Complete the transfer with payload. + let receipt; + { + // Start new transaction. + const tx = new TransactionBlock(); + + // Parse and verify the vaa. + const [parsedVaa] = tx.moveCall({ + target: `${WORMHOLE_ID}::vaa::parse_and_verify`, + arguments: [ + tx.object(WORMHOLE_STATE_ID), + tx.pure(Array.from(signedWormholeMessage)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + // Verify the VAA with the token bridge. + const [tokenBridgeMessage] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::vaa::verify_only_once`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), parsedVaa], + }); + + // Authorize the transfer. + const [redeemerReceipt] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::complete_transfer_with_payload::authorize_transfer`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), tokenBridgeMessage], + typeArguments: [COIN_10_TYPE], + }); + + // Complete the tranfer. + tx.moveCall({ + target: `${HELLO_TOKEN_ID}::transfer::redeem_transfer_with_payload`, + arguments: [tx.object(stateId), redeemerReceipt], + typeArguments: [COIN_10_TYPE], + }); + + tx.setGasBudget(50_000); + + // NOTE: redeem the transfer with the recipient wallet. + receipt = await wallet.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEvents: true, + showBalanceChanges: true, + }, + }); + } + + // Fetch balance changes. + const recipientCoinChange = getBalanceChangeFromTransaction( + walletAddress, + COIN_10_TYPE, + receipt.balanceChanges + ); + + // Confirm that the recipient received the full mintAmount. + expect(recipientCoinChange).equals(mintAmount); + }); + }); + + describe("SUI Native Coin", () => { + // The `transferAmount` will be transferred outbound in the first + // The two following tests will use the `transferAmount` that is + // deposited in the bridge to test complete transfer functionality. + // For both tests to be successful, the following must be true: + // * transferAmount >= mintAmount1 + mintAmount2 + const outboundTransferAmount = "690000000000"; // 690 SUI + const suiDecimals = 9; + + it("Send tokens with payload", async () => { + expect(localVariables.stateId).is.not.undefined; + const stateId: string = localVariables.stateId; + + // Fetch wallet address. + const walletAddress = await wallet.getAddress(); + + // Fetch sui coins to pay the wormhole fee. + const feeAmount = await getWormholeFee(provider); + + // Balance check before transferring tokens. + const coinBalanceBefore = await provider.getBalance({ + owner: walletAddress, + coinType: SUI_TYPE, + }); + + // Start new transaction. + const tx = new TransactionBlock(); + + // Coins to transfer to the target chain. + const [wormholeFee, coinsToTransfer] = tx.splitCoins(tx.gas, [ + tx.pure(feeAmount), + tx.pure(outboundTransferAmount), + ]); + + // Fetch the asset info. + const [assetInfo] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::state::verified_asset`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID)], + typeArguments: [SUI_TYPE], + }); + + // Fetch the transfer ticket. + const [transferTicket] = tx.moveCall({ + target: `${HELLO_TOKEN_ID}::transfer::send_tokens_with_payload`, + arguments: [ + tx.object(stateId), + coinsToTransfer, + assetInfo, + tx.pure(foreignChain), + tx.pure(walletAddress), + tx.pure(nonce), + ], + typeArguments: [SUI_TYPE], + }); + + // Transfer the tokens with payload. + const [messageTicket] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::transfer_tokens_with_payload::transfer_tokens_with_payload`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), transferTicket], + typeArguments: [SUI_TYPE], + }); + + // Publish the message. + tx.moveCall({ + target: `${WORMHOLE_ID}::publish_message::publish_message`, + arguments: [ + tx.object(WORMHOLE_STATE_ID), + wormholeFee, + messageTicket, + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + tx.setGasBudget(50_000); + const eventData = await wallet.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEffects: true, + showEvents: true, + showBalanceChanges: true, + }, + }); + + // Fetch wormhole events. + const wormholeEvents = getWormholeEvents(eventData); + expect(wormholeEvents!.length).equals(1); + + // Parse the emitted Wormhole message and verify the payload. + const message = wormholeEvents![0].parsedJson; + expect(message.consistency_level).equal(0); + expect(message.sequence).equals("5"); + expect(message.nonce).equals(nonce); + + // Cache state. + const state = await getObjectFields(provider, stateId); + + // Verify the transfer payload. + { + const transferPayload = await parseTransferPayload( + Buffer.from(message.payload) + ); + expect(transferPayload.amount.toString()).to.equal( + tokenBridgeNormalizeAmount( + Number(outboundTransferAmount), + suiDecimals + ).toString() + ); + expect(transferPayload.fromAddress!).equals( + state!.emitter_cap.fields.id.id.substring(2) + ); + expect(transferPayload.originChain).to.equal(CHAIN_ID_SUI); + expect(transferPayload.targetAddress).to.equal( + foreignContractAddress.toString("hex") + ); + expect(transferPayload.targetChain).to.equal(Number(foreignChain)); + } + + // Verify the additional payload. + { + const helloTokenPayload = parseHelloTokenPayload( + Buffer.from(message.payload) + ); + expect(helloTokenPayload.payloadType).equals(1); + expect(helloTokenPayload.recipient).equals(walletAddress); + } + + // Balance check after transferring tokens. + const coinBalanceAfter = await provider.getBalance({ + owner: walletAddress, + coinType: SUI_TYPE, + }); + expect( + parseInt(coinBalanceBefore.totalBalance) - + parseInt(coinBalanceAfter.totalBalance) + ).gte(parseInt(outboundTransferAmount)); + }); + + it("Redeem transfer with relayer", async () => { + expect(localVariables.stateId).is.not.undefined; + + // Cache stateId and fetch the state. + const stateId: string = localVariables.stateId; + const state = await getObjectFields(provider, stateId); + + // Save wallet and relayer addresses. + const walletAddress = await wallet.getAddress(); + const relayerAddress = await relayer.getAddress(); + + // Define transfer parameters. + const mintAmount = Math.floor(Number(outboundTransferAmount) / 2); + const recipient = walletAddress; + const tokenAddress = await provider + .getCoinMetadata({ + coinType: SUI_TYPE, + }) + .then((result) => result!.id); + + // Create payload. + const payload = createHelloTokenPayload(recipient); + + // Create a transfer tokens with payload message. + const published = ethereumTokenBridge.publishTransferTokensWithPayload( + tokenAddress!.substring(2), + CHAIN_ID_SUI, // tokenChain + BigInt(tokenBridgeNormalizeAmount(mintAmount, suiDecimals)), + CHAIN_ID_SUI, // recipientChain + state!.emitter_cap.fields.id.id.substring(2), // targetContractAddress + foreignContractAddress, // fromAddress + Buffer.from(payload.substring(2), "hex"), + nonce + ); + + // Sign the transfer message. + const signedWormholeMessage = guardians.addSignatures(published, [0]); + + // Set the gas budget for the transaction block. + const gas_budget = 50_000; + + // Complete the transfer with payload. + let receipt; + { + // Start new transaction. + const tx = new TransactionBlock(); + + // Parse and verify the vaa. + const [parsedVaa] = tx.moveCall({ + target: `${WORMHOLE_ID}::vaa::parse_and_verify`, + arguments: [ + tx.object(WORMHOLE_STATE_ID), + tx.pure(Array.from(signedWormholeMessage)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + // Verify the VAA with the token bridge. + const [tokenBridgeMessage] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::vaa::verify_only_once`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), parsedVaa], + }); + + // Authorize the transfer. + const [redeemerReceipt] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::complete_transfer_with_payload::authorize_transfer`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), tokenBridgeMessage], + typeArguments: [SUI_TYPE], + }); + + // Complete the tranfer. + tx.moveCall({ + target: `${HELLO_TOKEN_ID}::transfer::redeem_transfer_with_payload`, + arguments: [tx.object(stateId), redeemerReceipt], + typeArguments: [SUI_TYPE], + }); + + tx.setGasBudget(gas_budget); + receipt = await relayer.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEvents: true, + showEffects: true, + showBalanceChanges: true, + }, + }); + } + + // Fetch balance changes. + const recipientCoinChange = getBalanceChangeFromTransaction( + walletAddress, + SUI_TYPE, + receipt.balanceChanges + ); + const relayerCoinChange = getBalanceChangeFromTransaction( + relayerAddress, + SUI_TYPE, + receipt.balanceChanges + ); + + // Expected relayer fee to be paid by the contract. + const expectedFee = calculateRelayerFee(mintAmount, state); + + // Validate relayer balance change. The balance changes should be less + // than the expectedFee, since the relayer pays gas. + expect(relayerCoinChange).gte(expectedFee - gas_budget); + + // Confirm recipient balance changes. + expect(recipientCoinChange).equals(mintAmount - expectedFee); + }); + + it("Recipient self redeems transfer", async () => { + expect(localVariables.stateId).is.not.undefined; + + // Cache stateId and fetch the state. + const stateId: string = localVariables.stateId; + const state = await getObjectFields(provider, stateId); + + // Save wallet and relayer addresses. + const walletAddress = await wallet.getAddress(); + + // Define transfer parameters. + const mintAmount = Math.floor(Number(outboundTransferAmount) / 2); + const recipient = walletAddress; + const tokenAddress = await provider + .getCoinMetadata({ + coinType: SUI_TYPE, + }) + .then((result) => result!.id); + + // Create payload. + const payload = createHelloTokenPayload(recipient); + + // Create a transfer tokens with payload message. + const published = ethereumTokenBridge.publishTransferTokensWithPayload( + tokenAddress!.substring(2), + CHAIN_ID_SUI, // tokenChain + BigInt(tokenBridgeNormalizeAmount(mintAmount, suiDecimals)), + CHAIN_ID_SUI, // recipientChain + state!.emitter_cap.fields.id.id.substring(2), // targetContractAddress + foreignContractAddress, // fromAddress + Buffer.from(payload.substring(2), "hex"), + nonce + ); + + // Sign the transfer message. + const signedWormholeMessage = guardians.addSignatures(published, [0]); + + // Set the gas budget. + const gas_budget = 50_000; + + // Complete the transfer with payload. + let receipt; + { + // Start new transaction. + const tx = new TransactionBlock(); + + // Parse and verify the vaa. + const [parsedVaa] = tx.moveCall({ + target: `${WORMHOLE_ID}::vaa::parse_and_verify`, + arguments: [ + tx.object(WORMHOLE_STATE_ID), + tx.pure(Array.from(signedWormholeMessage)), + tx.object(SUI_CLOCK_OBJECT_ID), + ], + }); + + // Verify the VAA with the token bridge. + const [tokenBridgeMessage] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::vaa::verify_only_once`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), parsedVaa], + }); + + // Authorize the transfer. + const [redeemerReceipt] = tx.moveCall({ + target: `${TOKEN_BRIDGE_ID}::complete_transfer_with_payload::authorize_transfer`, + arguments: [tx.object(TOKEN_BRIDGE_STATE_ID), tokenBridgeMessage], + typeArguments: [SUI_TYPE], + }); + + // Complete the tranfer. + tx.moveCall({ + target: `${HELLO_TOKEN_ID}::transfer::redeem_transfer_with_payload`, + arguments: [tx.object(stateId), redeemerReceipt], + typeArguments: [SUI_TYPE], + }); + + tx.setGasBudget(gas_budget); + + // NOTE: redeem the transfer with the recipient wallet. + receipt = await wallet.signAndExecuteTransactionBlock({ + transactionBlock: tx, + options: { + showEvents: true, + showBalanceChanges: true, + }, + }); + } + + // Fetch balance changes. + const recipientCoinChange = getBalanceChangeFromTransaction( + walletAddress, + SUI_TYPE, + receipt.balanceChanges + ); + + // Confirm that the recipient received the full mintAmount. The + // balance should change by slightly less than the mintAmount, + // since the user had to pay gas. + expect(recipientCoinChange).gte(mintAmount - gas_budget); + }); + }); + }); +}); diff --git a/sui/ts/tests/helpers/error.ts b/sui/ts/tests/helpers/error.ts new file mode 100644 index 0000000..1014822 --- /dev/null +++ b/sui/ts/tests/helpers/error.ts @@ -0,0 +1,5 @@ +import { expect } from "chai"; + +export function unexpected() { + expect(false).to.be.true; +} diff --git a/sui/ts/tests/helpers/index.ts b/sui/ts/tests/helpers/index.ts new file mode 100644 index 0000000..4e76872 --- /dev/null +++ b/sui/ts/tests/helpers/index.ts @@ -0,0 +1,2 @@ +export * from "./consts"; +export * from "./error"; diff --git a/sui/ts/tests/sui_config/client.yaml b/sui/ts/tests/sui_config/client.yaml new file mode 100644 index 0000000..c359ba1 --- /dev/null +++ b/sui/ts/tests/sui_config/client.yaml @@ -0,0 +1,12 @@ +--- +keystore: + File: ts/tests/sui_config/sui.keystore +envs: + - alias: localnet + rpc: "http://0.0.0.0:9000" + ws: ~ + - alias: devnet + rpc: "https://fullnode.devnet.sui.io:443" + ws: ~ +active_env: localnet +active_address: "0xfefa5ab8867a8fea4e96bca1193ed372d5a7bd8cf00a8df32302be79607e903c" diff --git a/sui/ts/tests/sui_config/fullnode.yaml b/sui/ts/tests/sui_config/fullnode.yaml new file mode 100644 index 0000000..39f7880 --- /dev/null +++ b/sui/ts/tests/sui_config/fullnode.yaml @@ -0,0 +1,45 @@ +--- +protocol-key-pair: + value: D2SK/oaPvHb3/GwdfFv9aGXeP8qnyMiJC1WSWT5xmbk= +worker-key-pair: + value: AMuHe+tAWGROny5uT2/prFAH8U4szkRppZtsF/E14zY+ +account-key-pair: + value: AIA+EJK7NI1T2NKG4hd2Ebysq0iE06dHXnJDhLCgIdS4 +network-key-pair: + value: AGrW4IygVKoxrWy5zxdkHU46bSOZIZefWL6nX7Xwp0KX +db-path: ts/tests/sui_config/authorities_db/full_node_db +network-address: /ip4/127.0.0.1/tcp/41723/http +json-rpc-address: "0.0.0.0:9000" +metrics-address: "127.0.0.1:44977" +admin-interface-port: 37251 +enable-event-processing: true +grpc-load-shed: ~ +grpc-concurrency-limit: ~ +p2p-config: + listen-address: "127.0.0.1:41059" + external-address: /ip4/127.0.0.1/udp/41059 + seed-peers: + - peer-id: debf5cea20c6919593ed30c7373b02ecc495b7a2f5d6d49192614507a762a0ce + address: /ip4/127.0.0.1/udp/40217 + - peer-id: 669e44c597737be4aff66e752b61c4fc195c85bf5ce74ecf93dd24aa94726d3d + address: /ip4/127.0.0.1/udp/43399 + - peer-id: 571339b3f20d277cc67c824628a4b3b89dd5a26d2d2fc3a6c809ae39a7abdc26 + address: /ip4/127.0.0.1/udp/33809 + - peer-id: 3859364b09fed78a3f1426e37b1e2129ad7f560921b3e34bcb0ba6e4126f3be3 + address: /ip4/127.0.0.1/udp/38471 +genesis: + genesis-file-location: ts/tests/sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 1 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 10 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 diff --git a/sui/ts/tests/sui_config/genesis.blob b/sui/ts/tests/sui_config/genesis.blob new file mode 100644 index 0000000000000000000000000000000000000000..d6dde3ba2cf146412b7e07e75f44c9bbcd9ae035 GIT binary patch literal 202349 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�|Pr^ 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 cGv6Qk)^X_8h^BL13JC6Hvj+t literal 0 HcmV?d00001 diff --git a/sui/ts/tests/sui_config/network.yaml b/sui/ts/tests/sui_config/network.yaml new file mode 100644 index 0000000..f7c3760 --- /dev/null +++ b/sui/ts/tests/sui_config/network.yaml @@ -0,0 +1,297 @@ +--- +validator_configs: + - protocol-key-pair: + value: VTDx4HjVmRBqdqBWg2zN+zcFE20io3CrBchGy/iV1lo= + worker-key-pair: + value: AADxeIjGebS2URkFA5t9jQ8638QMC2nUj6v6xIVj2lOz + account-key-pair: + value: ANK1fjgOf2GTXSE0m9sZjlrGnr+WzWyCkItHGtlENbrI + network-key-pair: + value: ALmQEkz1SUpqhCftqoXRGjkF7qglhH3ig4VXnU3+/+lT + db-path: ts/tests/sui_config/authorities_db/99f25ef61f80 + network-address: /ip4/127.0.0.1/tcp/41419/http + json-rpc-address: "127.0.0.1:42489" + metrics-address: "127.0.0.1:35781" + admin-interface-port: 41707 + consensus-config: + address: /ip4/127.0.0.1/tcp/38819/http + db-path: ts/tests/sui_config/consensus_db/99f25ef61f80 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/37013/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/42677/http + network_admin_server: + primary_network_admin_server_port: 43965 + worker_network_admin_server_base_port: 33157 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ + enable-event-processing: false + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:40217" + external-address: /ip4/127.0.0.1/udp/40217 + genesis: + genesis-file-location: ts/tests/sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 1 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 10 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + - protocol-key-pair: + value: avYcyVgYMXTyaUYh9IRwLK0gSzl7YF6ZQDAbrS1Bhvo= + worker-key-pair: + value: ANwIykK/Bc5CjfRl3UjbX1J+ZM8IrAL/eNkSN5mVtCfb + account-key-pair: + value: AEVJNm8X9UqeqG4Ba93vCOZAubzT6gD/hIkfEHN0+vDj + network-key-pair: + value: AAR+w04MHiPvGT9s8RN1H4xtmeSW7nQtOjLh5TkvzQpq + db-path: ts/tests/sui_config/authorities_db/8dcff6d15504 + network-address: /ip4/127.0.0.1/tcp/38477/http + json-rpc-address: "127.0.0.1:45869" + metrics-address: "127.0.0.1:45197" + admin-interface-port: 34033 + consensus-config: + address: /ip4/127.0.0.1/tcp/46699/http + db-path: ts/tests/sui_config/consensus_db/8dcff6d15504 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/33681/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/44867/http + network_admin_server: + primary_network_admin_server_port: 35151 + worker_network_admin_server_base_port: 46805 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ + enable-event-processing: false + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:43399" + external-address: /ip4/127.0.0.1/udp/43399 + genesis: + genesis-file-location: ts/tests/sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 1 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 10 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + - protocol-key-pair: + value: OXnx3yM1C/ppgnDMx/o1d49fJs7E05kq11mXNae/O+I= + worker-key-pair: + value: APFaE/LsORvf5ajtHEZIC5B9tSxnoB4SD7otcaVioocx + account-key-pair: + value: AOwFNNwaP6UVhZ4B4gLIx2+0PI9fVwBenafL5VuoDHEg + network-key-pair: + value: ANnediYYt8nwYMt1Jix9qm2bJUxSQLeTgkiYy4Qd07hq + db-path: ts/tests/sui_config/authorities_db/addeef94d898 + network-address: /ip4/127.0.0.1/tcp/36343/http + json-rpc-address: "127.0.0.1:46019" + metrics-address: "127.0.0.1:41631" + admin-interface-port: 46301 + consensus-config: + address: /ip4/127.0.0.1/tcp/40065/http + db-path: ts/tests/sui_config/consensus_db/addeef94d898 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/46517/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/43275/http + network_admin_server: + primary_network_admin_server_port: 41311 + worker_network_admin_server_base_port: 38867 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ + enable-event-processing: false + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:33809" + external-address: /ip4/127.0.0.1/udp/33809 + genesis: + genesis-file-location: ts/tests/sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 1 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 10 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 + - protocol-key-pair: + value: CyNkjqNVr3HrHTH7f/NLs7u5lUHJzuPAw0PqMTD2y2s= + worker-key-pair: + value: ALe5f9owpcZeOBolxs60Fnuv2zRISbB14J+87XP4hiA1 + account-key-pair: + value: APg5GMTm6C6BVL6c0VDXiUmUbXSfHCW/tK4N+6Zcl0al + network-key-pair: + value: AE50PIMLxjfzhjvLX+8/vPo5lWh49okxNQZm1o2N+lSq + db-path: ts/tests/sui_config/authorities_db/b3fd5efb5c87 + network-address: /ip4/127.0.0.1/tcp/39975/http + json-rpc-address: "127.0.0.1:41115" + metrics-address: "127.0.0.1:35859" + admin-interface-port: 35517 + consensus-config: + address: /ip4/127.0.0.1/tcp/45685/http + db-path: ts/tests/sui_config/consensus_db/b3fd5efb5c87 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/34665/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/45329/http + network_admin_server: + primary_network_admin_server_port: 33461 + worker_network_admin_server_base_port: 35171 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ + enable-event-processing: false + grpc-load-shed: ~ + grpc-concurrency-limit: 20000000000 + p2p-config: + listen-address: "127.0.0.1:38471" + external-address: /ip4/127.0.0.1/udp/38471 + genesis: + genesis-file-location: ts/tests/sui_config/genesis.blob + authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 1 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true + end-of-epoch-broadcast-channel-capacity: 128 + checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 10 + db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false + indirect-objects-threshold: 18446744073709551615 +account_keys: + - QOitKozediY16NrbquZp13LJnh0ylKgRhbFPvX4BZsM= + - aomvIepVU/1qjbdAIqVSejVYD3KQYlCkqNvn+u56OGE= + - lpAV7ERavhZLtTFjbIQE1ktMjQUKQjxA1abbdtQ0DXQ= + - 8n/ZDR2fKWpjj5Bbx5z+g1WzfLRDJWWMclrkPDXku+0= + - IxLh6YFTNQPS9xiiJIzZnyLaqzgwysp4VFljcv+ldgo= +genesis: AAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAIBm1v+ULZfJ/IRUELCASc8qvnbd26dBGurAnA87wSXpKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARUL+UYcBAAAAAAAAAAAAAAAAALLkM9syBrUy6D8/B47+1/lrNIkdKE1C3PfBo0cLLJOgv5U1DAaAjCKy6kShA6mSExg6MAAAAQAAAAAAAwAQAAAAAAABAAIAAwAAASB44/TodZknpRQWc2/vnAXleCs0lfmbTiUepkK6Yl3dKCAtG+oqYHUB9PihuyH1OcSyhsIG/L2tMmzoqJipydLG+AEAAQAAAAACMAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAAAAAAAAAsDYmNzXKEc6wsGAAAABgEAAgMCBgUIBwcPDQgcIAw8BAAAAAEAAQEAAQYJAAEKAgNiY3MIdG9fYnl0ZXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQABAgAABGhhc2hqoRzrCwYAAAAGAQACAwIKBQwDBw8XCCYgDEYIAAAAAQAAAAACAAAAAQoCBGhhc2gIc2hhMl8yNTYIc2hhM18yNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQABAgABAQIAAAVhc2NpaZcGoRzrCwYAAAALAQAEAgQOAxJUBGYIBW47B6kByAEI8QIgBpEDCgqbAwsMpgO6Ag3gBQQABQAQAAIHAAAABwABAQcBAAAACAABAAAUAgMAABUCBAAAAwUGAAASBwgAABEJAQAADgUKAAAEBQsAAAoDAgAABgEAAAANAAYAAAsABgABCQ0OAQABDAwGAQABDwgNAQABEw4NAQANAwwDDgMPAwECAQgBAQoCAQgAAQsCAQgAAQYIAAEBAgcIAAgBAAEHCAABAwEGCgIBBgsCAQkAAQsCAQkAAQkAAgMDBENoYXIGT3B0aW9uBlN0cmluZxhhbGxfY2hhcmFjdGVyc19wcmludGFibGUIYXNfYnl0ZXMFYXNjaWkEYnl0ZQVieXRlcwRjaGFyDGRlc3Ryb3lfc29tZQppbnRvX2J5dGVzEWlzX3ByaW50YWJsZV9jaGFyB2lzX3NvbWUNaXNfdmFsaWRfY2hhcgZsZW5ndGgEbm9uZQZvcHRpb24IcG9wX2NoYXIJcHVzaF9jaGFyBHNvbWUGc3RyaW5nCnRyeV9zdHJpbmcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAABAAAAAAAAAgEHCgIBAgEGAgABAAAICQoAEQoEBAUGBwAnCwASAQIBAQAABAwLABECDAEOATgABAcFCQcAJwsBOAECAgEAAA8eDgBBAAwCBgAAAAAAAAAADAEoCgEKAiMEGQULDgAKAUIAFBEKIAQUOAICCwEGAQAAAAAAAAAWDAEFBSgLABIAOAMCAwEAAA8gCgAQAEEADAIGAAAAAAAAAAAMASgKAQoCIwQdBQwKABAACgFCABQRCyAEGAsAAQkCCwEGAQAAAAAAAAAWDAEFBigIAgQBAAAIBwsADwAOARABFEQAAgUBAAAIBQsADwBFABIBAgYBAAAIBAsAEQdBAAIHAQAACAMLABAAAggBAAAIAwsAEwACCQEAAAgDCwATAQIKAQAACAQLADF/JQILAQAABg0KADEgJgQJCwAxfiUMAQULCQwBCwECAAABAAAFZGVidWd0oRzrCwYAAAAGAQACAwILBQ0FBxIeCDAgDFAIAAAAAQABAQAAAgEBAAEGCQAABWRlYnVnBXByaW50EXByaW50X3N0YWNrX3RyYWNlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQIAAQECAAAGb3B0aW9u8QihHOsLBgAAAA0BAAQCBAYDCngEggEOBZABhwEHlwLbAQjyAyAGkgQUCqYEBwutBAIMrwSABA2vCAIOsQgCAA8AFgAABwEAAAAOAAEBAAARAgEBAAAMAwQBAAANAwQBAAAEBQQBAAABAwYBAAADBQYBAAAKBwIBAwAJCAABAAAICQIBAAACCQoBAAASCAIBAAATCAEBAAAHCwIBAgAGAQIBAAAFAQABAAAUAQwBAAEEDgQBAAELDQQBAAEQAgwBABMCEgIRAgMCAAIBAgICAAELAAEJAAEJAAEGCwABCQABAQIGCwABCQAGCQABBgkAAgYLAAEJAAkAAgcLAAEJAAkAAQcLAAEJAAEHCQACCwABCQAJAAEKCQABBgoJAAIGCgkABgkAAgYJAAYKCQACCQAGCgkAAQcKCQACCQAHCgkAAwsAAQkACwABCQAHCgkAAgkACgkABk9wdGlvbgZib3Jyb3cKYm9ycm93X211dBNib3Jyb3dfd2l0aF9kZWZhdWx0CGNvbnRhaW5zDGRlc3Ryb3lfbm9uZQxkZXN0cm95X3NvbWUUZGVzdHJveV93aXRoX2RlZmF1bHQHZXh0cmFjdARmaWxsEGdldF93aXRoX2RlZmF1bHQIaXNfZW1wdHkHaXNfbm9uZQdpc19zb21lBG5vbmUGb3B0aW9uCXNpbmdsZXRvbgRzb21lBHN3YXAMc3dhcF9vcl9maWxsBnRvX3ZlYwN2ZWMGdmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAABAAAAAAAAwgBAAQAAAAAAAACARUKCQAAAgABAAAAA0ACAAAAAAAAAAA5AAIBAQAAAAQLADgAOQACAgEAAAAECwA3ADgBAgMBAAAABQsANwA4ASACBAEAAAAFCwA3AAsBOAICBQEAAAANCgA4AwQEBQgLAAEHAScLADcABgAAAAAAAAAAQgICBgEAAA8TCwA3AAwDCgM4AQQLCwMBCwEMAgURCwEBCwMGAAAAAAAAAABCAgwCCwICBwEAABASCwA3AAwDCgM4AQQLCwMBCwEMAgUQCwMGAAAAAAAAAABCAhQMAgsCAggBAAAREAsANgAMAgoCLjgBBAgFDAsCAQcAJwsCCwFEAgIJAQAAAA0KAC44AwQFBQkLAAEHAScLADYARQICCgEAAAAOCgAuOAMEBQUJCwABBwEnCwA2AAYAAAAAAAAAAEMCAgsBAAASFAoALjgDBAUFCQsAAQcBJwsANgAMAwoDRQIMAgsDCwFEAgsCAgwBAAATFQsANgAMBAoELjgBBAo4BAwCBQ4KBEUCOAUMAgsCDAMLBAsBRAILAwINAQAAFA8LADoADAMNAy44AQQKCwEMAgUNDQNFAgwCCwICDgEAABQQDgA4AwQEBQYHAScLADoADAINAkUCDAELAkYCAAAAAAAAAAALAQIPAQAAAAoOADgGBAQFBgcAJwsAOgBGAgAAAAAAAAAAAhABAAAAAwsAOgACAAAAAgAGc3RyaW5n+QehHOsLBgAAAAsBAAgCCA4DFnIEiAEIBZABeweLAvgBCIMEIAajBBQKtwQGDL0EhQMNwgcCABMABAARABgAAQcAAQEHAAIABwEAAAAXAAEAAAYCAQAAFQECAAAWAAMAAAUEBQAADgQGAAAPBAcAAAIICQAAAwoJAAAICwkAABQMAQAABw0HAAAJBQYAAAsOBgAADA8AAAAKEAcAAQ0CAAABEwACAAIQCRIBAAISERIBAAMCFQkBAAMOFAYBABMBEgEVExQTAQoCAQgAAQgBAQsCAQgAAQYIAAEGCgIBAQEDAgcIAAgAAAIHCAAKAgMHCAADCAADBggAAwMCBggABggAAgYKAgMDBgoCAwMCBgoCBgoCAQkAAQsCAQkAAQIBBgoJAAIHCgkACgkACAEDAwMGCgIIAAgAAwUBAQEGCgIDBk9wdGlvbgZTdHJpbmcGYXBwZW5kC2FwcGVuZF91dGY4BWFzY2lpBWJ5dGVzCmZyb21fYXNjaWkIaW5kZXhfb2YGaW5zZXJ0E2ludGVybmFsX2NoZWNrX3V0ZjgRaW50ZXJuYWxfaW5kZXhfb2YZaW50ZXJuYWxfaXNfY2hhcl9ib3VuZGFyeRNpbnRlcm5hbF9zdWJfc3RyaW5nCmludG9fYnl0ZXMIaXNfZW1wdHkGbGVuZ3RoBG5vbmUGb3B0aW9uBHNvbWUGc3RyaW5nCnN1Yl9zdHJpbmcIdG9fYXNjaWkIdHJ5X3V0ZjgEdXRmOAZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAQAAAAAAAAADCAIAAAAAAAAAAAIBBQoCAAEAAAkJDgARDAQEBQYHACcLABIAAgEBAAAJBAsAERASAAICAQAACQQLABMAERECAwEAAAMMDgARDAQICwASADgADAEFCjgBDAELAQIEAQAACQMLABAAAgUBAAAJBAsAEAA4AgIGAQAACQQLABAAQRMCBwEAAAkHCwAPAA4BEAAUOAMCCAEAAAkFCwALAREAEQcCCQEAABY4CgAQAAwHCgEKB0ETJQQNCwcKARENDAMFEQsHAQkMAwsDBBQFGAsAAQcBJwoALhEGDAoKAAoBDAQuBgAAAAAAAAAACwQRCgwJCgALAQsKDAYMBS4LBQsGEQoMCA0JCwIRBw0JCwgRBwsJCwAVAgoBAAAXMAsAEAAMBgoGQRMMBwoCCwclBA8KAQoCJQwDBREJDAMLAwQYCgYKARENDAQFGgkMBAsEBCEKBgoCEQ0MBQUjCQwFCwUEJgUqCwYBBwEnCwYLAQsCEQ4SAAILAQAACQYLABAACwEQABEPAgwAAgANAAIADgACAA8AAgAAAAAGdmVjdG9ykQihHOsLBgAAAAgBAAIDAmYEaAQFbGEHzQGaAQjnAiAGhwMKDJED2AQAEQAFAAEBAAAJAgMBAAABBAUBAAALBgABAAACBwgBAAAKCQoBAAAEAQABAAAPCwABAAAOCgEBAAANCQABAAAADAABAAAIAg0BAAADDg0BAAAGDg8BAAAMBwoBAAAHEAABAAAQBwoBAAkKCwoAAQoJAAEGCgkAAQMCBgoJAAMBBgkAAgcKCQAJAAIHCgkAAwEHCQABBwoJAAEJAAMHCgkAAwMCBwoJAAoJAAEBAgYKCQAGCQACAQMDBwoJAAkAAwMDAwMCAwMDAwcKCQADBmFwcGVuZAZib3Jyb3cKYm9ycm93X211dAhjb250YWlucw1kZXN0cm95X2VtcHR5BWVtcHR5CGluZGV4X29mBmluc2VydAhpc19lbXB0eQZsZW5ndGgIcG9wX2JhY2sJcHVzaF9iYWNrBnJlbW92ZQdyZXZlcnNlCXNpbmdsZXRvbgRzd2FwC3N3YXBfcmVtb3ZlBnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAIAAAAAAAABAgABAQIAAgECAAMBAgAEAQIABQECAAYBAgAHAQIACAEAAAEHQAoAAAAAAAAAAAwBDQELAEQKCwECCQEAABEmCgAuQQoMAwoDBgAAAAAAAAAAIQQLCwABAgYAAAAAAAAAAAwCCwMGAQAAAAAAAAAXDAEKAgoBIwQjBRYKAAoCCgFHCgsCBgEAAAAAAAAAFgwCCwEGAQAAAAAAAAAXDAEFEQsAAQIKAQAAABENATgADgE4ASAEDAUHCgANAUUKRAoFAgsAAQsBRgoAAAAAAAAAAAILAQAAAAULAEEKBgAAAAAAAAAAIQIMAQAAEiEGAAAAAAAAAAAMAgoAQQoMAwoCCgMjBBsFCgoACgJCCgoBIQQWCwABCwEBCAILAgYBAAAAAAAAABYMAgUFCwABCwEBCQINAQAAEiMGAAAAAAAAAAAMAgoAQQoMAwoCCgMjBBwFCgoACgJCCgoBIQQXCwABCwEBCAsCAgsCBgEAAAAAAAAAFgwCBQULAAELAQEJBgAAAAAAAAAAAg4BAAATJQoALkEKDAQKAQoEJgQMCwABBwAnCwQGAQAAAAAAAAAXDAQKAQoEIwQiBRUKAAwDCgEMAgsBBgEAAAAAAAAAFgwBCwMLAgoBRwoFEAsARQoCDwEAAAMgCgAuQQoMAwoCCgMkBAwLAAEHACcKAAsBRAoKAgoDIwQdBRQKAAoCCgNHCgsCBgEAAAAAAAAAFgwCBQ8LAAECEAEAAAMXCgAuOAEgBAYFCgsAAQcAJwoALkEKBgEAAAAAAAAAFwwCCgALAQsCRwoLAEUKAgAHYWRkcmVzc2WhHOsLBgAAAAYBAAIDAgUFBwMHCg8IGSAMORAAAAABAAEAAAEDB2FkZHJlc3MGbGVuZ3RoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQAAAAIGIAAAAAAAAAACAAl0eXBlX25hbWWMBKEc6wsGAAAACgEABgIGCAMOKQU3LAdjeQjcASAG/AEHCoMCBgyJAtMBDdwDAgANAAIABAABBwACAAcAAAYAAQEAAAUCAwAABwIEAAAIAgQAAAkBBAABCgAGAAIDAwcAAgwJBAAAAQgAAQYIAAEGCAEBCAEECgIDAwYKAgEDAQYKAgECAQoCBQIGAgMKAgYKAgZTdHJpbmcIVHlwZU5hbWUHYWRkcmVzcwhhc19ieXRlcwVhc2NpaQ1ib3Jyb3dfc3RyaW5nA2dldAtnZXRfYWRkcmVzcwpnZXRfbW9kdWxlC2ludG9fc3RyaW5nBmxlbmd0aARuYW1lBnN0cmluZwl0eXBlX25hbWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIBOgoCAQAAAgELCAEAAQIAAQEAAAADCwAQAAICAQAABSERBQYCAAAAAAAAABgMAwsAEAARBgwEBwEMAQYAAAAAAAAAAAwCCgIKAyMEHAURDQEKBAoCQggURAgLAgYBAAAAAAAAABYMAgUMCwQBCwERBwIDAQAACicRBQYCAAAAAAAAABgGAgAAAAAAAAAWDAMLABAAEQYMBQcBDAQKBQoDQggMAgcADAEKAg4BIgQgBRcNBAsCFEQICwMGAQAAAAAAAAAWDAMFDAsFAQsCAQsEEQcCBAEAAAAEDgAQABQCAAAACmJpdF92ZWN0b3KrBqEc6wsGAAAACgEAAgICBAMGIwUpJAdNbQi6ASAG2gEoCoICCAyKAu8DDfkFBAACAAAHAAAGAAEAAAcCAwAACQIDAAAIAgMAAAMEBQAABAYAAAAFBAAAAQMBCAACBwgAAwACBggAAwEBAQYIAAIKAQMBBwEFAwcBAwMDCUJpdFZlY3RvcgliaXRfZmllbGQKYml0X3ZlY3Rvcgxpc19pbmRleF9zZXQGbGVuZ3RoIGxvbmdlc3Rfc2V0X3NlcXVlbmNlX3N0YXJ0aW5nX2F0A25ldwNzZXQKc2hpZnRfbGVmdAV1bnNldAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAIAAAAAAAMIAQACAAAAAAADCAEAAAAAAAAAAwgABAAAAAAAAAACAgQDAQoBAAEAAAclCgAGAAAAAAAAAAAkBAUFBwcBJwoABwMjBAwFDgcBJwYAAAAAAAAAAAwCQAUAAAAAAAAAAAwBKAoCCgAjBCAFGA0BCUQFCwIGAQAAAAAAAAAWDAIFEigLAAsBEgACAQEAAAgUCgEKABAAQQUjBAcFCwsAAQcAJwsADwALAUMFDAIICwIVAgIBAAAIFAoBCgAQAEEFIwQHBQsLAAEHACcLAA8ACwFDBQwCCQsCFQIDAQAACVkKAQoAEAEUJgQhCgAQAEEFDAYGAAAAAAAAAAAMBAoECgYjBB4FEQoADwAKBEMFDAMJCwMVCwQGAQAAAAAAAAAWDAQFDAsAAQVYCgEMBQoFCgAQARQjBEEFKgoACgUMAi4LAhEEBDcKAAoFCgEXEQEFPAoACgUKARcRAgsFBgEAAAAAAAAAFgwFBSMKABABFAsBFwwFCgUKABABFCMEVgVOCgAKBRECCwUGAQAAAAAAAAAWDAUFRwsAAQIEAQAAAxEKAQoAEABBBSMEBwULCwABBwAnCwAQAAsBQgUUAgUBAAADBAsAEABBBQIGAQAAACUKAQoAEAEUIwQHBQsLAAEHACcKAQwCCgIKABABFCMEIQUUCgAKAhEEIAQcCwABBSELAgYBAAAAAAAAABYMAgUNCwILARcCAAEAAAANZml4ZWRfcG9pbnQzMtYEoRzrCwYAAAAKAQACAgIEAwYeBSQWBzp6CLQBIAbUAUQKmAIFDJ0CiQINpgQCAAQAAAcAAAcAAQAAAwABAAABAgMAAAIBAwAABQMBAAAGAwQAAgMIAAEDAgMDAQgAAQEBBAQBBAQEAAxGaXhlZFBvaW50MzIUY3JlYXRlX2Zyb21fcmF0aW9uYWwVY3JlYXRlX2Zyb21fcmF3X3ZhbHVlCmRpdmlkZV91NjQNZml4ZWRfcG9pbnQzMg1nZXRfcmF3X3ZhbHVlB2lzX3plcm8MbXVsdGlwbHlfdTY0BXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEEP//////////AAAAAAAAAAADCAEAAQAAAAAAAwgCAAIAAAAAAAMIAwACAAAAAAADCAQAAQAAAAAAAwgFAAIAAAAAAAACAQgDAAEAAAUUCwA1DgEQABQ1GDEgMAwCCgIHACUEDwURBwMnCwI0AgEBAAAFHQ4BEAAUBgAAAAAAAAAAIgQHBQkHBCcLADUxIC8OARAAFDUaDAIKAgcAJQQYBRoHAicLAjQCAgEAAAYwCgA1MUAvDAULATUxIC8MBAoEMgAAAAAAAAAAAAAAAAAAAAAiBA8FEQcBJwsFCwQaDAMKAzIAAAAAAAAAAAAAAAAAAAAAIgQcCAwCBSALAAYAAAAAAAAAACEMAgsCBCMFJQcFJwoDBwAlBCoFLAcFJwsDNBIAAgMBAAAHAwsAEgACBAEAAAcEDgAQABQCBQEAAAcGDgAQABQGAAAAAAAAAAAhAgAAAAcNZml4ZWRfcG9pbnQzMgxGaXhlZFBvaW50MzIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQZvcHRpb24GT3B0aW9uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEFYXNjaWkGU3RyaW5nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEFYXNjaWkEQ2hhcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCmJpdF92ZWN0b3IJQml0VmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEGc3RyaW5nBlN0cmluZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCXR5cGVfbmFtZQhUeXBlTmFtZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAMAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQAAAAAAAAApA2JhZ+wFoRzrCwYAAAALAQAIAggMAxRwBIQBDAWQAVIH4gG5AQibAyAGuwMKCsUDCAzNA+YBDbMFBAAEAAsAEgAVAAAMAAICBAADAQIAABEAAQAAAwIDAgcEAAUEBQIHBAAGBgcCBwQAEwYIAgcEAAcECQEHAAgECQIHBAAQCgsAAA8KCQAACgEDAAEDDgMCBwQBBQ8FAgcEAQYQBwIHBAEMDwkBBwENDwkCBwQBExAIAgcEAgkMAwACEQAMAAoNCw0MDQ8NDREODQEHCAIBCAADBwgACQAJAQACBggACQABBgkBAgcIAAkAAQcJAQEJAQEBAQYIAAEDAQgBAgkACQEDBwgBCQAJAQIGCAEJAAIHCAEJAAEJAAIIAQMDQmFnCVR4Q29udGV4dANVSUQDYWRkA2JhZwZib3Jyb3cKYm9ycm93X211dAhjb250YWlucxJjb250YWluc193aXRoX3R5cGUGZGVsZXRlDWRlc3Ryb3lfZW1wdHkNZHluYW1pY19maWVsZAdleGlzdHNfEGV4aXN0c193aXRoX3R5cGUCaWQIaXNfZW1wdHkGbGVuZ3RoA25ldwZvYmplY3QGcmVtb3ZlBHNpemUKdHhfY29udGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAACAg4IARQDAAEAAAMFCwAREQYAAAAAAAAAABIAAgEBAAADDgoADwALAQsCOAAKABABFAYBAAAAAAAAABYLAA8BFQICAQAAAwULABAACwE4AQIDAQAAAwULAA8ACwE4AgIEAQAACA8KAA8ACwE4AwwCCgAQARQGAQAAAAAAAAAXCwAPARULAgIFAQAAAwULABAACwE4BAIGAQAAAwULABAACwE4BQIHAQAAAwQLABABFAIIAQAAAwYLABABFAYAAAAAAAAAACECCQEAABIOCwATAAwCDAELAgYAAAAAAAAAACEECQULBwAnCwEREAIAAAABAANiY3OVD6Ec6wsGAAAACwEACgIKCgMUhwEEmwEYBbMBgwEHtgLeAgiUBUAG1AU3CosGBgyRBssIDdwOAgADAQMBCgEfAAIAAAcAAgEHAQAAAB4AAQEAAAgBAgAABgIBAAALAwQAAAwDBQAAFAMGAAATAwcAABIDCAAAFwMHAAAVAwkAABYDCgAAGgMBAAAbAwsAABkDDAAAGAMNAAANAw4AAA4DDwAAEQMQAAAQAxEAAA8DEgABHgABAQACCRMhAQACHRQhAQADHBUTAQAEBQEEAAQHEwcAFBQXBhYEFQQWBRUFFgYVBhYHFQcWCBUIAQYJAAEKAgEIAAEHCAABBQEBAQIBAwEEAQoFAQoBAQoKAgEKAwEKBAELAQEFAQsBAQEBCwEBAgELAQEDAQsBAQQAAQkAAQcKCQACCgIDAgECAwMCAwMEAgQEAwMCAwMDAwoFAwMDCgEDAwMKAgMDAwoKAgMDAwoDAwMDCgQBCwEBCQADQkNTBk9wdGlvbgdhZGRyZXNzA2JjcwVieXRlcwpmcm9tX2J5dGVzFGludG9fcmVtYWluZGVyX2J5dGVzBmxlbmd0aANuZXcEbm9uZQZvcHRpb24McGVlbF9hZGRyZXNzCXBlZWxfYm9vbBNwZWVsX29wdGlvbl9hZGRyZXNzEHBlZWxfb3B0aW9uX2Jvb2wQcGVlbF9vcHRpb25fdTEyOA9wZWVsX29wdGlvbl91NjQOcGVlbF9vcHRpb25fdTgJcGVlbF91MTI4CHBlZWxfdTY0B3BlZWxfdTgQcGVlbF92ZWNfYWRkcmVzcw1wZWVsX3ZlY19ib29sD3BlZWxfdmVjX2xlbmd0aA1wZWVsX3ZlY191MTI4DHBlZWxfdmVjX3U2NAtwZWVsX3ZlY191OA9wZWVsX3ZlY192ZWNfdTgHcmV2ZXJzZQRzb21lCHRvX2J5dGVzBnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAAKBQEACgEBAAoCAQAKCgIBAAoDAQAKBAEAAAIBBAoCAAEAABMDCwA4AAIBAQAAEwUNADgBCwASAAICAQAAAQcLABMADAENATgBCwECAwEAABYjCgAQAEEGERkmBAcFCwsAAQcAJ0AGAAAAAAAAAAAGAAAAAAAAAAAMAgwBCgIRGSMEHgUUDQEKAA8ARQZEBgsCBgEAAAAAAAAAFgwCBQ8LAAELAREYAgQBAAAXFQsAEQUMAgoCMQAhBAoJDAEFEwsCMQEhBA8FEQcBJwgMAQsBAgUBAAATDwoAEABBBgYBAAAAAAAAACYEBwULCwABBwAnCwAPAEUGAgYBAAAYKAoAEABBBgYIAAAAAAAAACYEBwULCwABBwAnBgAAAAAAAAAAMQAMAgwDCgIxQCMEJAUUCgAPAEUGNAwBCwMLAQoCLxYMAwsCMQgWDAIFDwsAAQsDAgcBAAAZKAoAEABBBgYQAAAAAAAAACYEBwULCwABBwAnMgAAAAAAAAAAAAAAAAAAAAAxAAwCDAMKAjGAIwQkBRQKAA8ARQY1DAELAwsBCgIvFgwDCwIxCBYMAgUPCwABCwMCCAEAABowBgAAAAAAAAAAMQAGAAAAAAAAAAAMAgwDDAQKAgYEAAAAAAAAACUECwUPCwABBwInCgAPAEUGNAwBCwIGAQAAAAAAAAAWDAILBAoBBn8AAAAAAAAAHAoDLxsMBAsBBoAAAAAAAAAAHAYAAAAAAAAAACEEJwUsCwMxBxYMAwUGCwABCwQCCQEAABsZCgARCAYAAAAAAAAAAAcDDAMMAQwCCgEKAiMEFQUMDQMKABEDRAQLAQYBAAAAAAAAABYMAQUHCwABCwMCCgEAABwZCgARCAYAAAAAAAAAAAcEDAMMAQwCCgEKAiMEFQUMDQMKABEERAULAQYBAAAAAAAAABYMAQUHCwABCwMCCwEAAB0ZCgARCAYAAAAAAAAAAAcFDAMMAQwCCgEKAiMEFQUMDQMKABEFRAYLAQYBAAAAAAAAABYMAQUHCwABCwMCDAEAAB4ZCgARCAYAAAAAAAAAAAcGDAMMAQwCCgEKAiMEFQUMDQMKABELRAELAQYBAAAAAAAAABYMAQUHCwABCwMCDQEAAB8ZCgARCAYAAAAAAAAAAAcHDAMMAQwCCgEKAiMEFQUMDQMKABEGRAcLAQYBAAAAAAAAABYMAQUHCwABCwMCDgEAACAZCgARCAYAAAAAAAAAAAcIDAMMAQwCCgEKAiMEFQUMDQMKABEHRAgLAQYBAAAAAAAAABYMAQUHCwABCwMCDwEAAA4OCgARBAQICwARAzgCDAEFDAsAATgDDAELAQIQAQAADw4KABEEBAgLABEEOAQMAQUMCwABOAUMAQsBAhEBAAAQDgoAEQQECAsAEQU4BgwBBQwLAAE4BwwBCwECEgEAABEOCgARBAQICwARBjgIDAEFDAsAATgJDAELAQITAQAAEg4KABEEBAgLABEHOAoMAQUMCwABOAsMAQsBAgAAAANoZXizCqEc6wsGAAAACAEABAMEFQQZAgUbJQdALAhsQAasAZ8GDMsHwgIABAEFAAMAAAAAAQAAAAACAQEAAQADBAEAAwEBCgIBAgUKCgIHCgIDAwoCAgcKCQAKCQAABAIDAwoCBQEBAQICBmFwcGVuZAZkZWNvZGULZGVjb2RlX2J5dGUGZW5jb2RlA2hleAZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAAKCgKCBoACAjAwAjAxAjAyAjAzAjA0AjA1AjA2AjA3AjA4AjA5AjBhAjBiAjBjAjBkAjBlAjBmAjEwAjExAjEyAjEzAjE0AjE1AjE2AjE3AjE4AjE5AjFhAjFiAjFjAjFkAjFlAjFmAjIwAjIxAjIyAjIzAjI0AjI1AjI2AjI3AjI4AjI5AjJhAjJiAjJjAjJkAjJlAjJmAjMwAjMxAjMyAjMzAjM0AjM1AjM2AjM3AjM4AjM5AjNhAjNiAjNjAjNkAjNlAjNmAjQwAjQxAjQyAjQzAjQ0AjQ1AjQ2AjQ3AjQ4AjQ5AjRhAjRiAjRjAjRkAjRlAjRmAjUwAjUxAjUyAjUzAjU0AjU1AjU2AjU3AjU4AjU5AjVhAjViAjVjAjVkAjVlAjVmAjYwAjYxAjYyAjYzAjY0AjY1AjY2AjY3AjY4AjY5AjZhAjZiAjZjAjZkAjZlAjZmAjcwAjcxAjcyAjczAjc0Ajc1Ajc2Ajc3Ajc4Ajc5AjdhAjdiAjdjAjdkAjdlAjdmAjgwAjgxAjgyAjgzAjg0Ajg1Ajg2Ajg3Ajg4Ajg5AjhhAjhiAjhjAjhkAjhlAjhmAjkwAjkxAjkyAjkzAjk0Ajk1Ajk2Ajk3Ajk4Ajk5AjlhAjliAjljAjlkAjllAjlmAmEwAmExAmEyAmEzAmE0AmE1AmE2AmE3AmE4AmE5AmFhAmFiAmFjAmFkAmFlAmFmAmIwAmIxAmIyAmIzAmI0AmI1AmI2AmI3AmI4AmI5AmJhAmJiAmJjAmJkAmJlAmJmAmMwAmMxAmMyAmMzAmM0AmM1AmM2AmM3AmM4AmM5AmNhAmNiAmNjAmNkAmNlAmNmAmQwAmQxAmQyAmQzAmQ0AmQ1AmQ2AmQ3AmQ4AmQ5AmRhAmRiAmRjAmRkAmRlAmRmAmUwAmUxAmUyAmUzAmU0AmU1AmU2AmU3AmU4AmU5AmVhAmViAmVjAmVkAmVlAmVmAmYwAmYxAmYyAmYzAmY0AmY1AmY2AmY3AmY4AmY5AmZhAmZiAmZjAmZkAmZlAmZmCgIBAAABAAACIQYAAAAAAAAAAAcDDgBBAQwEDAUMAwoDCgQjBB8FDA0FDAIHAgwBCwIOAQ4ACgNCARQ0QgAUOAALAwYBAAAAAAAAABYMAwUHCwUCAQEAAAUvBgAAAAAAAAAABwMOAEEBDAMMBAwCCgMGAgAAAAAAAAAZBgAAAAAAAAAAIQQOBRAHACcKAgoDIwQtBRUOAAoCQgEUEQIxEBgOAAoCBgEAAAAAAAAAFkIBFBECFgwBDQQLAUQBCwIGAgAAAAAAAAAWDAIFEAsEAgIAAAAGQDEwCgAlBAkKADE6IwwBBQsJDAELAQQSCwAxMBcMBQU+MUEKACUEGwoAMUcjDAIFHQkMAgsCBCYxCgsAFjFBFwwEBTwxYQoAJQQvCgAxZyMMAwUxCQwDCwMENAU2BwEnMQoLABYxYRcMBAsEDAULBQIAA3BhecMGoRzrCwYAAAAJAQAIAggKAxJNBF8OBW1+B+sBrQEImAMgBrgDCgzCA9YCAAkAAgAPABABAAwBAAEDAQIAAAgAAQEAAAwCAQEAAA4DAQEAAA0EAQEAAAMCAQEAAAUFAQEAAAYGAQEAAAcHAQEAAQQCEAEAAQUFAQEAAQwCCgEAAgoLAQEMAwsICQALCgoMAAwBDAgMCQwGDAILAAEJAAYIAQADBwsAAQkAAwcIAQMHCwABCQAKAwcIAQQHCwABCQADBQcIAQIHCwABCQALAAEJAAIHCwABCQAKCwABCQACCgsAAQkABQEGCAEBBQELAAEJAAIJAAUBCQACAwMBAwMDAwoLAAEJAAEKCwABCQADCwABCQADAwRDb2luCVR4Q29udGV4dARjb2luD2RpdmlkZV9hbmRfa2VlcA1kaXZpZGVfaW50b19uBGpvaW4Iam9pbl92ZWMVam9pbl92ZWNfYW5kX3RyYW5zZmVyBGtlZXADcGF5D3B1YmxpY190cmFuc2ZlcgZzZW5kZXIFc3BsaXQSc3BsaXRfYW5kX3RyYW5zZmVyCXNwbGl0X3ZlYwh0cmFuc2Zlcgp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAAEAAAEFCwALAREMOAACAQEEAAEICwALAQoCOAELAi44AgICAQQADRsGAAAAAAAAAAAOAUEODAQMAwoDCgQjBBYFCgoADgEKA0IOFAoCOAMLAwYBAAAAAAAAABYMAwUFCwABCwIBAgMBBAABBwsACwELAzgBCwI4AAIEAQQADx8LAAsBCgI4BAwFBgAAAAAAAAAADgVBCgwEDAMKAwoEIwQaBQ8NBUUKCgIuEQw4AAsDBgEAAAAAAAAAFgwDBQoLAgELBUYKAAAAAAAAAAACBQEEAAEECwALATgFAgYBBAARGgYAAAAAAAAAAA4BQQoMBAwDCgMKBCMEFQUKDQFFCgwCCgALAjgFCwMGAQAAAAAAAAAWDAMFBQsAAQsBRgoAAAAAAAAAAAIHAQQAChIOAEEKBgAAAAAAAAAAJAQGBQgHACcNAEUKDAINAgsAOAYLAgsBOAACAANzdWnYBqEc6wsGAAAACgEADgIOMAM+PgR8DgWKAYUBB48CgQIIkARABtAEZgq2BQUMuwVtABYBEgAJAAoAFwAZABoABAIAAQMHAQAAAgAEAQABAgUEAQABAwEMAQABAwIMAQABAwYMAQABBQcCAAYIBwAAEAABAAAXAgMAAREDCQEAAgwQBwEAAg8REgEAAwsLDAECAxgPEAEABBMOAwEMBBQUAwEMBQ4FBwAFFQUGAAIIBQoHDQYKBAoDCggTAQcIBwELAgEIAAILBAEIAAUABAsFAQgACwMBCAALAgEIAAsGAQgAAQYIBwEFAQMBCAgBCwEBCQABCAAHCQACCgIKAgoCCwEBCAgHCAcCCwYBCQALBQEJAAELBQEIAAEJAAELBgEJAAELAwEJAAIHCwMBCQADAQsCAQkAAQsEAQgAAgkABQdCYWxhbmNlBENvaW4MQ29pbk1ldGFkYXRhBk9wdGlvbgNTVUkGU3VwcGx5C1RyZWFzdXJ5Q2FwCVR4Q29udGV4dANVcmwHYmFsYW5jZQRjb2luD2NyZWF0ZV9jdXJyZW5jeQ5kZXN0cm95X3N1cHBseQtkdW1teV9maWVsZAVlcG9jaA9pbmNyZWFzZV9zdXBwbHkDbmV3BG5vbmUGb3B0aW9uFHB1YmxpY19mcmVlemVfb2JqZWN0D3B1YmxpY190cmFuc2ZlcgZzZW5kZXIDc3VpCHRyYW5zZmVyFHRyZWFzdXJ5X2ludG9fc3VwcGx5CnR4X2NvbnRleHQDdXJsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgAypo7AAAAAAMIAOQLVAIAAAADCAAA6IkEI8eKBSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoCBANTVUkKAgQDU3VpCgIBAAACAQ0BAAAAAAQvCgAuEQoHBSEEBwULCwABBwEnCgAuEQkGAAAAAAAAAAAhBBIFFgsAAQcAJwkSADEJBwYHBwcIOAALADgBDAEMBAsBOAILBDgDDAINAgcEOAQMAwsCOAUBCwMCAQEEAAMECwALATgGAgADdXJsqgKhHOsLBgAAAAkBAAQCBAgDDBkFJRQHOU4IhwFACscBBgzNATIN/wECAAgBAgABBwABAAcAAAQAAQAABQIBAAADAwAAAAcEBQABBgIAAAEIAQEIAAEKAgEGCAACBwgACAEABlN0cmluZwNVcmwFYXNjaWkJaW5uZXJfdXJsCm5ld191bnNhZmUVbmV3X3Vuc2FmZV9mcm9tX2J5dGVzBnN0cmluZwZ1cGRhdGUDdXJsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQACAQgIAQABAAAFAwsAEgACAQEAAAUECwARBBIAAgIBAAAFBAsAEAAUAgMBAAAFBQsBCwAPABUCAAAABGNvaW6BEqEc6wsGAAAADQEAFgIWPgNUmwIE7wIkBZMD4wIH9gWiBQiYC0AG2AseCvYLNAuqDAgMsgz0BA2mEQ4OtBEOAA8BCwEtATIADAAZACwAOQA7ADwAQQABDAEAAQACDAEAAQAHDAEAAQADAwEAAQEFBwACBAcBAAADBQcABAAEAQABBAYEAQABBgkEAAgIAgAKCgcAADgAAQEAADoCAwEAADMEBQEAADQEBgEAAEMHAQEAAAwHCAEAAA0JCgEAABoLDAEAACMMDQEAADcODAEAAC8PEAEAACUREAEAADESDAEAABcSEwEAAEQUDAEAABYMEAEAABAVFgECACYXDAEAACgYDQEAAA4ZAQEAACcaEAEAAD8bEAEAAEAcEAEAAD0bEAEAAD4cEAEAABsdHgEAAB4dHwEAAB8dIAEAABwdHwEAAB0dIQEAATIqIAACMCIvAQADQiofAAQRIgMBAgQTLAEBAAQWDRABAAQiKw0BAAQlJQEBAAQxJA0BAAQ1BQEBAARDCAEBAAREEA0BAAUYIhABAwYUIxAABioUIwAHLi0QAQwJJCcoAQIKKyAuACciKCImIggiJSIJIgQiDCIpIiMiLiIqKSEiJCIiIhEiLQwfLgEGCwIBCQABAwELAgEJAAELCAEJAAEHCwIBCQABBgsIAQkAAQcLCAEJAAEGCwABCQABBgsHAQkAAQcLAAEJAAEHCwcBCQACCwcBCQAHCAoBCwABCQABCwcBCQADBwsHAQkAAwcICgIHCwcBCQALAAEJAAACBwsAAQkACwABCQADBwsAAQkAAwcICgEKCwABCQABBwgKBwkAAgoCCgIKAgsFAQgLBwgKAgsCAQkACwEBCQADBwsCAQkAAwcICgIHCwIBCQADAgcLAgEJAAsAAQkABAcLAgEJAAMFBwgKAwYLAgEJAAcLAQEJAAgGAwYLAgEJAAcLAQEJAAgEAQYLAQEJAAECAQgGAQgEAQsFAQgLAQkAAQgJAgcLBwEJAAMCBwsHAQkACwcBCQADAwMKCwABCQABBgkAAQEBCwMBCQABCgICBwsIAQkAAwIHCwgBCQALBwEJAAIJAAUBCAsBCwUBCQAHQmFsYW5jZQRDb2luDENvaW5NZXRhZGF0YQ9DdXJyZW5jeUNyZWF0ZWQGT3B0aW9uBlN0cmluZwZTdXBwbHkLVHJlYXN1cnlDYXAJVHhDb250ZXh0A1VJRANVcmwFYXNjaWkHYmFsYW5jZQtiYWxhbmNlX211dARidXJuBGNvaW4PY3JlYXRlX2N1cnJlbmN5DWNyZWF0ZV9zdXBwbHkIZGVjaW1hbHMPZGVjcmVhc2Vfc3VwcGx5BmRlbGV0ZQtkZXNjcmlwdGlvbgxkZXN0cm95X3plcm8NZGl2aWRlX2ludG9fbgRlbWl0BWV2ZW50DGZyb21fYmFsYW5jZQxnZXRfZGVjaW1hbHMPZ2V0X2Rlc2NyaXB0aW9uDGdldF9pY29uX3VybAhnZXRfbmFtZQpnZXRfc3ltYm9sCGljb25fdXJsAmlkD2luY3JlYXNlX3N1cHBseQxpbnRvX2JhbGFuY2UTaXNfb25lX3RpbWVfd2l0bmVzcwRqb2luBG1pbnQRbWludF9hbmRfdHJhbnNmZXIMbWludF9iYWxhbmNlBG5hbWUDbmV3Cm5ld191bnNhZmUGb2JqZWN0Bm9wdGlvbg9wdWJsaWNfdHJhbnNmZXIDcHV0BHNvbWUFc3BsaXQGc3RyaW5nBnN1cHBseQpzdXBwbHlfbXV0DHN1cHBseV92YWx1ZQZzeW1ib2wEdGFrZQx0b3RhbF9zdXBwbHkIdHJhbnNmZXIUdHJlYXN1cnlfaW50b19zdXBwbHkKdHhfY29udGV4dAV0eXBlcxJ1cGRhdGVfZGVzY3JpcHRpb24PdXBkYXRlX2ljb25fdXJsC3VwZGF0ZV9uYW1lDXVwZGF0ZV9zeW1ib2wDdXJsBHV0ZjgFdmFsdWUEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAAAAgIhCAkMCwcBCQABAgYhCAkSAikIBjYIBBUIBiALBQEICwICAiEICTgLCAEJAAMCARICAiIAIgMiASIAAQAAEAQLADcAOAACAQEAAAMGCwA6AAwBESsLAQICAQAAEAMLADcAAgMBAAAQAwsANgACBAEAABAECwA3ATgBAgUBAAAQAwsANwECBgEAABADCwA2AQIHAQAAEAULAREsCwA5AQIIAQAADQYLADoBDAERKwsBAgkBAAAQBwsCESwLAAsBOAI5AQIKAQAAEAYLAAsBOAM4BAECCwEEAA0KCwE6AQwCESsLADYBCwI4BAECDAEAABAGCwA2AQsBCwI4BQINAQAAJjsKAQYAAAAAAAAAACQEBQULCwABCwIBBwEnCgEKAC44BiUEEgUYCwABCwIBBwInQAwAAAAAAAAAAAwFBgAAAAAAAAAADAMKAC44BgoBGgwEKAoDCgEGAQAAAAAAAAAXIwQ1BSoNBQoACgQKAjgHRAwLAwYBAAAAAAAAABYMAwUiCwABCwIBCwUCDgEAABAFCwARLDgIOQECDwEAAA0HCwA6AQwBESsLATgJAhABAAAQHA4AOAoEBAUICwYBBwAnCgE5AjgLCgYRLAsAOAw5AAsGESwLAQsDESALAhEeCwQRIAsFOQMCEQEAABAICwIRLAsANgALATgNOQECEgEAABAFCwA2AAsBOA0CEwEEAA0JCwE6AQwCESsLADYACwI4DgIUAQQAEAcLAAsBCwM4DwsCOBACFQEEABAFCwILATYCFQIWAQQAEAULAgsBNgMVAhcBBAAQBQsCCwE2BBUCGAEEABAHCwIRLzgRCwE2BRUCGQEAABAECwA3BhQCGgEAABAECwA3AhQCGwEAABAECwA3AxQCHAEAABAECwA3BBQCHQEAABAECwA3BRQCAgEAAQECAQMBBAEFAQEAIgEiAiIDIgQiBSIGIgAEaGFzaHGhHOsLBgAAAAYBAAIDAgoFDAcHExoILSAMTQgAAQAAAAEAAAIAAQABBgoCAQoCCmJsYWtlMmIyNTYEaGFzaAlrZWNjYWsyNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgABAgABAQIAAARobWFjZKEc6wsGAAAABgEAAgMCBQUHCgcREwgkIAxEBAAAAAEAAQACBgoCBgoCAQoCBGhtYWMNaG1hY19zaGEzXzI1NgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAAEbWF0aKcFoRzrCwYAAAAGAQACAwIjBSUSBzc5CHAgDJAB+QMAAgADAAEAAAQAAQAAAAABAAAFAgEAAAYBAQAABwMDAAABAAEAAgMDAQMCAwIBBAMEBAQDDw8PBGRpZmYTZGl2aWRlX2FuZF9yb3VuZF91cARtYXRoA21heANtaW4DcG93BHNxcnQJc3FydF91MTI4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQAAAQsKAAoBJAQHCwAMAgUJCwEMAgsCAgEBAAABCwoACgEjBAcLAAwCBQkLAQwCCwICAgEAAAEPCgAKASQECQsACwEXDAIFDQsBCwAXDAILAgIDAQAAASEGAQAAAAAAAAAMAgoBMQEmBB8FBwoBMQIZMQAhBBYKAAsAGAwACwExAhoMAQUeCwIKABgMAgsBMQEXDAEFAgsCAgQBAAAEKzIAAAAAAAAAAAEAAAAAAAAADAEyAAAAAAAAAAAAAAAAAAAAAAwCCwA1DAMKATIAAAAAAAAAAAAAAAAAAAAAIgQoBQwKAwoCCgEWJgQfCwMKAgoBFhcMAwsCMQEwCgEWDAIFIwsCMQEwDAILATECMAwBBQcLAjQCBQEAAAUrSgAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAADAFKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAgsATQwDCgFKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiBCgFDAoDCgIKARYmBB8LAwoCCgEWFwwDCwIxATAKARYMAgUjCwIxATAMAgsBMQIwDAEFBwsCNQIGAQAAARMKAAoBGQYAAAAAAAAAACEECwsACwEaDAIFEQsACwEaBgEAAAAAAAAAFgwCCwICAAVjbG9ja6IDoRzrCwYAAAALAQAIAggMAxQfBDMCBTUeB1N6CM0BIAbtASwKmQIIDKECTw3wAgIAAwAHAAsADAAACAABAgQAAwECAAAKAAEAAAUCAwAABAQDAAEDAwYAAgkIAwEIAwgCBQAEBwEGCAABAwEGCAIAAwcIAAMGCAIBBQEIAQEIAAEJAAVDbG9jawlUeENvbnRleHQDVUlEBWNsb2NrGWNvbnNlbnN1c19jb21taXRfcHJvbG9ndWUGY3JlYXRlAmlkBm9iamVjdAZzZW5kZXIMc2hhcmVfb2JqZWN0DHRpbWVzdGFtcF9tcwh0cmFuc2Zlcgp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgYIAQoDAAEAAAMECwAQABQCAQAAAAMNCwARBQcBIQQGBQgHACcRAwYAAAAAAAAAABIAOAACAgAAAAMPCwIRBQcBIQQGBQoLAAEHACcLAQsADwAVAgABAAVlY3ZyZooBoRzrCwYAAAAHAQACAwIFBQcPBxYTCCkgBkkeDGcEAAAAAQABAAQGCgIGCgIGCgIGCgIBAQVlY3ZyZgxlY3ZyZl92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAABAgAABWV2ZW50V6Ec6wsGAAAABgEAAgMCBgUIBAcMCwgXIAw3BAABAAAAAQEDAQkAAARlbWl0BWV2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQIAAAVraW9za6kZoRzrCwYAAAANAQAWAhZOA2SjAgSHAzQFuwO7Awf2BrMGCKkNQAbpDVoKww5IC4sPBAyPD8MJDdIYEg7kGAYAKgEzABIAFAAXABgAGgAyAEYASABJAAUMAAAGDAAACgwBDAEAAwcAAAcHAAAIBwAABAMBDAEBCQcBAAACAAQBAAEDAQwBAAEHAgcABw8EAAgLAgAJDAwBAAEJDQABAAEKDgIAADAAAQAAEwIDAABFBAUAADUGBQEMAC4HBQEMAEcICQEMACwKBQEMADYLBQEMADsMDQEMAC0ODwEMAD8QDQEMAEIRBQEMAE4SAwAAHxMUAAAlExQAACMTFAAAJBMUAAAeFRQAAEsVFgAARBcFAABKGBYAADQZGgAAJxkbAAA5GRwAADoVHQAAPR4fAQwAPB4fAQwAPh4cAQwBFj4JAQABJj0UAQACKTYcAQACTT8cAQACTwUjAQADHSkqAQADISojAQADR0AqAQADTTUcAQAEECwFAgcEBBtCFAEHBEAwMgIHBARBMDECBwQFECwFAgcMBRtCFAEHBUAwMgIHDAYZCQUBAwcVIQUAByAmHwEIBzAAIQAHTCgfAAkxNzgBAApDJBoAICIuJSEiLgkpKyUtAwkoLysrJS8sMwYJJy8kIiIiHiIoLTEJCAkdHBwcHyIjIipBJkMmRAEHCA8CCAAIAQMIAAgBBwgPAQsJAQgMAwcIAAYIAQYIDwADBwgABggBCQAEBwgABggBBgsNAQkACQADBwgABggBCAoBCQAEBwgABggBCAoDBAcIAAYIAQkAAwMHCAAICgsJAQgMAgkACw4BCQAFBwgABggBCAoDBwgPAQsCAQkAAwcIAAsCAQkACwkBCAwCBwgACwIBCQAEBwgABggBCwcBAwcIDwIGCAAICgEBAgcIAAYIAQEHCAsDBwgABggBAQEHCAABBggAAQUBDgEDAQcLCAEIDAEGCwIBCQABCAoCCAEIAAEICwEIDAELCAEJAAEGCA8BCAABBgkABQgLCAoICw4LCAEIDAEGCAsCCwgBCQAHCA8BCwkBCQACCAMJAAMHCAsJAAkBAggFAQIICggKAggEAwIHCAsJAAELBwEJAQEJAQELBgEJAAIJAAMBBgsJAQkAAgcLCAEJAAsIAQkAAwgKAwgKAQsOAQkABggKCAsICggKAwgLBQgLCAoICgMDAwgLCAoICgMDAwMBBgsHAQkAAQsHAQkAAQYLCAEJAAMHCwgBCQADBwgPAQgDAgYICwkAAQgFAQgEB0JhbGFuY2UEQ29pbgJJRARJdGVtCkl0ZW1MaXN0ZWQFS2lvc2sNS2lvc2tPd25lckNhcAdMaXN0aW5nBExvY2sGT3B0aW9uC1B1cmNoYXNlQ2FwA1NVSQ5UcmFuc2ZlclBvbGljeQ9UcmFuc2ZlclJlcXVlc3QJVHhDb250ZXh0A1VJRANhZGQQYWxsb3dfZXh0ZW5zaW9ucwdiYWxhbmNlEmNsb3NlX2FuZF93aXRoZHJhdwRjb2luBmRlbGV0ZQxkZXN0cm95X3NvbWUNZHluYW1pY19maWVsZBRkeW5hbWljX29iamVjdF9maWVsZARlbWl0BWV2ZW50B2V4aXN0c18DZm9yDGZyb21fYmFsYW5jZQpoYXNfYWNjZXNzCGhhc19pdGVtAmlkDGludG9fYmFsYW5jZQxpc19leGNsdXNpdmUJaXNfbGlzdGVkFWlzX2xpc3RlZF9leGNsdXNpdmVseQlpc19sb2NrZWQHaXNfc29tZQppdGVtX2NvdW50B2l0ZW1faWQEam9pbgVraW9zawhraW9za19pZARsaXN0Fmxpc3Rfd2l0aF9wdXJjaGFzZV9jYXAEbG9jawltaW5fcHJpY2UDbmV3C25ld19yZXF1ZXN0Bm9iamVjdAZvcHRpb24Fb3duZXIFcGxhY2UOcGxhY2VfYW5kX2xpc3QFcHJpY2UHcHJvZml0cw5wcm9maXRzX2Ftb3VudAtwcm9maXRzX211dAhwdXJjaGFzZRFwdXJjaGFzZV9jYXBfaXRlbRJwdXJjaGFzZV9jYXBfa2lvc2sWcHVyY2hhc2VfY2FwX21pbl9wcmljZRFwdXJjaGFzZV93aXRoX2NhcAZyZW1vdmUQcmVtb3ZlX2lmX2V4aXN0cxNyZXR1cm5fcHVyY2hhc2VfY2FwBnNlbmRlchRzZXRfYWxsb3dfZXh0ZW5zaW9ucwlzZXRfb3duZXIDc3VpBHRha2UPdHJhbnNmZXJfcG9saWN5CnR4X2NvbnRleHQHdWlkX211dBB1aWRfbXV0X2FzX293bmVyDHVpZF90b19pbm5lcgV2YWx1ZQh3aXRoZHJhdwR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAMIBgAAAAAAAAADCAcAAAAAAAAAAwgIAAAAAAAAAAACBSAICzgLCAEIDDQFJw4RAQECAiAICxwICgICBCAICysICigICi8DAwIBIAgKBAICIAgKIgEFAgEgCAoGAgMqCAogCAo3AwYJAgkAAQAAIBMKABEvOAAKAC4RMkkAAAAACBIADAILABEvDgI4ARIBDAELAgsBAgEBAAAnJgsAEwABDAYBDAcMBQsBEwEMBAwDDgURMAsEIQQRBRULAgEHACcLBkkAAAAAIQQaBR4LAgEHAycLAxEtCwURLQsHCwI4AgICAQAABRUKAC44AQsBEAAUIQQJBQ8LAAELAgEHACcLAhEyCwAPARUCAwEAAAUdCgAuOAELARAAFCEECQUNCwABBwAnCgAQAhRJAQAAABYKAA8CFQsADwMOAjgDEgMLAjgEAgQBAAAFDAoADwMOAzgDEgUIOAULAAsBCwM4BgIFAQAALjwKAC44AQsBEAAUIQQJBQ0LAAEHACcKAAoCDAMuCwMRDiAEFgUaCwABBwgnCgAKAgwELgsEERAgBCMFJwsAAQcEJwoAEAIUSQEAAAAXCgAPAhUKAA8DCgIJEgQ4BwELAA8DCwISAzgIAgYBAAAfKQoALjgBCwEQABQhBAkFDQsAAQcAJwoACgIMBC4LBBEQIAQWBRoLAAEHBCcKAA8DCgIJEgQKAzgJCwAuOAELAgsDOQA4CgIHAQAAHw0OAjgDDAQKAAoBCwI4BgsACwELBAsDOAsCCAEAADQzCgAPAwoBCRIEOAwMBAoADwMKARIDOAgMAwoAEAIUSQEAAAAXCgAPAhUKBA4COA0hBBsFHwsAAQcBJwoADwQLAjgOOA8BCgAPAwoBEgU4EAELAwsBCwQLAC44ATgRAgkBAAA5PAoALjgBCgEQABQhBAkFEQsAAQsEAQsBAQcAJwoACgIMBS4LBREPIAQaBSILAAELBAELAQEHBicLBBEvDAoLAA8DCgIIEgQKAzgJCwoMBgsCDAcLARAAFAwICwMMCQsGCwgLBwsJOQECCgEAADoyCwE6AQwGDAQMBQwDDgI4DQwHCgcLBiYEDgUSCwABBwEnCgAuOAELBSEEGQUdCwABBwUnCgAPAwoECBIEOAwBCgAPAwoECRIECwc4CQsDES0LAAsECwI4EgILAQAAOxsLAToBAQwDDAQMAgoALjgBCwQhBA0FEQsAAQcFJwsADwMLAwgSBDgMAQsCES0CDAEAADwxCgAuOAELARAAFCEECQUPCwABCwMBBwAnDgI4EwQlCwI4FAwGCgYKABAEOBUlBBwFIgsAAQsDAQcCJwsGDAQFKQoAEAQ4FQwECwQMBQsADwQLBQsDOBYCDQEAAAUGCwAQAwsBEgM4FwIOAQAABQYLABADCwESBTgYAg8BAAAUEgoAEAMKAQkSBDgZBAwLAAEIDAIFEAsACwEREAwCCwICEAEAAAUHCwAQAwsBCBIEOBkCEQEAAAUICwAuOAELARAAFCECEgEAAAUQCgAuOAELARAAFCEECQUNCwABBwAnCwAPAwITAQAABRIKAC44AQsBEAAUIQQJBQ0LAAEHACcLAgsADwUVAhQBAAAFDAoAEAUUBAUFCQsAAQcHJwsADwMCFQEAAAUECwAQARQCFgEAAAUECwAQAhQCFwEAAAUECwAQBDgVAhgBAAAFEAoALjgBCwEQABQhBAkFDQsAAQcAJwsADwQCGQEAAAUECwA3ABQCGgEAAAUECwA3ARQCGwEAAAUECwA3AhQCAQEAAgADAAAAAQAEAgECAgIDBgkHCQgJAAV0YWJsZYIGoRzrCwYAAAANAQAIAggQAxhzBIsBCgWVAWgH/QGnAQikAyAGxAMKCs4DCAvWAwIM2APlAQ29BQQOwQUEABMACgAQABQAAAwCBwEEAQICBAADAQIAAA8AAQIHBAADAgMCBwQABAQFAgcEAAUGBwIHBAARBggCBwQABgQJAgcEAA4KCwIHBAANCgkCBwQACAEDAgcEAAkBAwIHBgEDDgMCBwQBBA8FAgcEAQUQBwIHBAELDwkCBwQBERAIAgcEAgcMAwACDwAMAAoNCw0MDQ4NDQ0BBwgCAQsAAgkACQEDBwsAAgkACQEJAAkBAAIGCwACCQAJAQkAAQYJAQIHCwACCQAJAQkAAQcJAQEJAQEBAQYLAAIJAAkBAQMBCAECCQAJAQMHCAEJAAkBAgYIAQkAAgcIAQkAAggBAwVUYWJsZQlUeENvbnRleHQDVUlEA2FkZAZib3Jyb3cKYm9ycm93X211dAhjb250YWlucwZkZWxldGUNZGVzdHJveV9lbXB0eQRkcm9wDWR5bmFtaWNfZmllbGQQZXhpc3RzX3dpdGhfdHlwZQJpZAhpc19lbXB0eQZsZW5ndGgDbmV3Bm9iamVjdAZyZW1vdmUEc2l6ZQV0YWJsZQp0eF9jb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAAICDAgBEgMADQABAAADBQsAERAGAAAAAAAAAAA5AAIBAQAAAw4KADYACwELAjgACgA3ARQGAQAAAAAAAAAWCwA2ARUCAgEAAAMFCwA3AAsBOAECAwEAAAMFCwA2AAsBOAICBAEAAAgPCgA2AAsBOAMMAgoANwEUBgEAAAAAAAAAFwsANgEVCwICBQEAAAMFCwA3AAsBOAQCBgEAAAMECwA3ARQCBwEAAAMGCwA3ARQGAAAAAAAAAAAhAggBAAARDgsAOgAMAgwBCwIGAAAAAAAAAAAhBAkFCwcAJwsBEQ8CCQEAAAMFCwA6AAERDwIAAAABAA0BDQAFdHlwZXNooRzrCwYAAAAGAQACAwIGBQgGBw4aCCggDEgEAAEAAAABAQIBBgkAAQETaXNfb25lX3RpbWVfd2l0bmVzcwV0eXBlcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAAGYm9ycm93/gShHOsLBgAAAA0BAAgCCBgDIDsEWwoFZVMHuAGeAQjWAkAGlgMUCqoDEwu9AwIMvwN9DbwEBA7ABAQABQEPAA4AEwADBAEMAAAAAAABAgcBAAACAQcAAwQCAAAMAAEBDAAFAgMBDAAQBAUBDAAGAQYBDAEHCQYBAAEICwYBAAEJDwUBAAESBgkBAAILDA0BCAMKBwgABwYFBggGBgYEBgIJAAcIBAELAAEJAAEHCwABCQACCQAIAQMHCwABCQAJAAgBAAEJAAEHCAQBBQELAgEJAAIIAwkAAQcLAgEJAAEGCQABCAMCCAMFAgcLAgEJAAkABkJvcnJvdwJJRAZPcHRpb24IUmVmZXJlbnQJVHhDb250ZXh0BmJvcnJvdwdkZXN0cm95DGRlc3Ryb3lfc29tZQdleHRyYWN0BGZpbGwUZnJlc2hfb2JqZWN0X2FkZHJlc3MCaWQDbmV3A29iagZvYmplY3QGb3B0aW9uCHB1dF9iYWNrA3JlZgRzb21lCnR4X2NvbnRleHQFdmFsdWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAAAAgILBRQLAgEJAAECAhEFDQgDAAYAAQAABQYLAREJCwA4ADkAAgEBAAAKDgoANgA4AQwCDgI4AgwBCwILADcBFAsBEgECAgEAAA4eCwITAQwDDAQOATgCCwMhBAoFDgsAAQcBJwoANwEUCwQhBBUFGQsAAQcAJwsANgALATgDAgMBAAAJBwsAOgAMAQELATgEAgABAAAABgEGAAZvYmplY3S3CKEc6wsGAAAADAEACAIIDAMUfgSSAQYFmAEjB7sB+gIItQRABvUEcArlBQsM8AWCAg3yBwQP9gcIABgBBAADAB4AAAcAAAIEAAMBAgAAFQABAAAUAAIAABMBAwAAEgIDAAAbBAUAAAgGBQAAHwcAAAAiBwMAACEHAQAAIAcCAAAWCAUAAAkFBgAADwkDAQgABQkAAQgAEQkBAQgAEAkCAQgABgkHAQgAFwIFAAAKAgYAABkCBgABHAkBAQACDgECAAMNCAIAAxoEAgAUAhAKFAMBBggAAQoCAQUBCAABBggCAQgBAAEGCAEBBwgCAQYJAAEJAAJJRAlUeENvbnRleHQDVUlEB2FkZHJlc3MDYmNzCWJvcnJvd19pZApib3Jyb3dfdWlkBWJ5dGVzBWNsb2NrBmRlbGV0ZQtkZWxldGVfaW1wbA1keW5hbWljX2ZpZWxkFGR5bmFtaWNfb2JqZWN0X2ZpZWxkFGZyZXNoX29iamVjdF9hZGRyZXNzCmZyb21fYnl0ZXMCaWQKaWRfYWRkcmVzcwhpZF9ieXRlcw9pZF9mcm9tX2FkZHJlc3MNaWRfZnJvbV9ieXRlcw1pZF90b19hZGRyZXNzC2lkX3RvX2J5dGVzA25ldxFuZXdfdWlkX2Zyb21faGFzaAZvYmplY3QOcmVjb3JkX25ld191aWQGc2VuZGVyEHN1aV9zeXN0ZW1fc3RhdGUIdG9fYnl0ZXMIdHJhbnNmZXIKdHhfY29udGV4dAx1aWRfYXNfaW5uZXIOdWlkX3RvX2FkZHJlc3MMdWlkX3RvX2J5dGVzDHVpZF90b19pbm5lcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFBSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgMIAAAAAAAAAAAFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBBwUBAgEPCAAAAQAABgQLABAAOAACAQEAAAYECwAQABQCAgEAAAYECwARFREDAgMBAAAGAwsAEgACBAAAAAYMCwARFwcDIQQGBQgHAicHABIAEgECBQMAAAYEBwESABIBAgYBAAAGAwsAEAECBwEAAAYECwAQARQCCAEAAAYFCwAQARAAOAACCQEAAAYFCwAQARAAFAIKAQAABgULABEWEgASAQILAQAABgULABMBEwAREgIMAQAABgULADgBEAEUAg0BAAAGBAsAOAEQAQIOAQAABgULADgBEAE4AgIPAQAABgYLADgBEAEQABQCEAACABEDAAAGBgoAERMLABIAEgECEgACABMAAgAAAAEAAAgACwAMAB0ABnByb3Zlcl2hHOsLBgAAAAQBAAIHAgcICSAGKR4AAAZwcm92ZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAAHYWRkcmVzc8oDoRzrCwYAAAAJAQAKAgoIAxI9BE8CBVEUB2WBAQjmAUAGpgI2DNwCRQABAQIBAwELAAgBAAcAAwAHAAAPAAEAAAcBAAAABgIAAAANAAIAAAwAAwAADgAEAAAJBQYAAAoFAQABCwIDAAINBwIBAAMFAwQABAQCAgAJAAEFAQ8BCgIBCAABCAEAAQMBBgkABlN0cmluZwdhZGRyZXNzBWFzY2lpA2JjcwZlbmNvZGUKZnJvbV9hc2NpaQpmcm9tX2J5dGVzCWZyb21fdTI1NgNoZXgGbGVuZ3RoA21heAZzdHJpbmcPdG9fYXNjaWlfc3RyaW5nCHRvX2J5dGVzCXRvX3N0cmluZwd0b191MjU2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIIAAAAAAAAAAPIP//////////////////////////////////////////AwgAAAAAAAAAAAABAgABAQIAAgECAAMBAAAFAw4AOAACBAEAAAUFCwARAxELEQgCBQEAAAUECwARBBEKAgYBAAAFAgcAAgcBAAAFAgcBAgAHYmFsYW5jZcgHoRzrCwYAAAAOAQAEAgQQAxRTBGcCBWljB8wB4AEIrAMgBswDSgqWBAoLoAQEDKQE2wIN/wYEDoMHBA+HBwIAAwAQAAEEAQABAAAEAQABAQICAAARAAEBAAAPAgEBAAAFAwQBAgAKBQYBAAAGBwEBAAATCAYBAAALCQEBAAANCgYBAAASCwYBAAAJBggBAAAEDAYBAAAHDQgBAAAIBAEBAAEMDg8ABwMBBgsBAQkAAQMBBgsAAQkAAQkAAQsAAQkAAgcLAAEJAAMBCwEBCQACBwsAAQkACwEBCQAAAgcLAQEJAAsBAQkAAgcLAQEJAAMBBwsBAQkAAgMGCAICCwEBCQAGCAIBBggCAQUHQmFsYW5jZQZTdXBwbHkJVHhDb250ZXh0B2JhbGFuY2UWY3JlYXRlX3N0YWtpbmdfcmV3YXJkcw1jcmVhdGVfc3VwcGx5D2RlY3JlYXNlX3N1cHBseRdkZXN0cm95X3N0b3JhZ2VfcmViYXRlcw5kZXN0cm95X3N1cHBseQxkZXN0cm95X3plcm8PaW5jcmVhc2Vfc3VwcGx5BGpvaW4Gc2VuZGVyBXNwbGl0A3N1aQxzdXBwbHlfdmFsdWUKdHhfY29udGV4dAV2YWx1ZQx3aXRoZHJhd19hbGwEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgERAwECAREDAAMBAwABAAAIBAsANwAUAgEBAAAIBAsANwEUAgIBAAAIAwYAAAAAAAAAADkAAgMBAAAIGAoBBv//////////CgA3ARQXIwQJBQ0LAAEHAScKADcBFAoBFgsANgEVCwE5AQIEAQAAARgLAToBDAIKADcBFAoCJgQKBQ4LAAEHAScKADcBFAoCFwsANgEVCwICBQEAAAgDBgAAAAAAAAAAOQECBgEAAAEPCwE6AQwCCgA3ABQLAhYKADYAFQsANwAUAgcBAAAIFgoANwAUCgEmBAcFCwsAAQcCJwoANwAUCgEXCwA2ABULATkBAggBAAABCAoANwAUDAELAAsBOAACCQEAAAgNDgA3ABQGAAAAAAAAAAAhBAcFCQcAJwsAOgEBAgoAAAAICwsBEQ0HBCEEBgUIBwMnCwA5AQILAAAACAwLARENBwQhBAYFCAcDJwsAOgEBAgwDAAAIAwsAOgACAQAAAAADAQMADgAHZGlzcGxheeYKoRzrCwYAAAANAQAQAhAuAz6EAQTCARYF2AHEAQecA98CCPsFQAa7BhQKzwYmC/UGBgz7BqADDZsKBg6hCgYADgEfABIAGgAbACAAIQAkAAAMAQgBAAEDAQgBAAgDAQgBAQQHAAMCBwADBgQABAMMAAYFAgAHBwcCAQAAAAAYAAEBCAAZAgEBCAAMAAMBCAAjBAMBCAAJBQMBCAALBgMBCAAPBQMBCAAdBwMBCAAXCAkBCAAlCgsBCAATCgwBCAANDQEBCAAKBQMBCAIQDgMBAwMYDRwAAyIVFgAEFAgJAQAFHBMDAQwGHhESAAcRAx4CAQAHFh8DAgEABx0aGwIBAAgOCw4ADgwOEQENFxUZEA4NHRMZFBkCBggGBwgHAQsAAQkABAYIBgoIAwoIAwcIBwABBwsAAQkAAwcLAAEJAAgDCAMDBwsAAQkACggDCggDAgcLAAEJAAgDAQYIBgEBAQYLAAEJAAENAQYLCAIIAwgDAQcIBwEJAAMLAAEJAAMDAQgDAQYIBwEFAgkABQINCwgCCAMIAwEGCAUBCAQBCwIBCQACAwMCCAMIAwIHCwgCCQAJAQYJAAIJAAkBAQgFAQsBAQkAAQsIAgkACQEDBwsIAgkACQEJAAkBB0Rpc3BsYXkORGlzcGxheUNyZWF0ZWQCSUQJUHVibGlzaGVyBlN0cmluZwlUeENvbnRleHQDVUlEBlZlY01hcA5WZXJzaW9uVXBkYXRlZANhZGQMYWRkX2ludGVybmFsDGFkZF9tdWx0aXBsZQ9jcmVhdGVfYW5kX2tlZXAPY3JlYXRlX2ludGVybmFsB2Rpc3BsYXkEZWRpdARlbWl0BWVtcHR5BWV2ZW50BmZpZWxkcwxmcm9tX3BhY2thZ2UCaWQGaW5zZXJ0DWlzX2F1dGhvcml6ZWQDbmV3D25ld193aXRoX2ZpZWxkcwZvYmplY3QHcGFja2FnZQ9wdWJsaWNfdHJhbnNmZXIGcmVtb3ZlBnNlbmRlcgZzdHJpbmcIdHJhbnNmZXIKdHhfY29udGV4dAx1aWRfdG9faW5uZXIOdXBkYXRlX3ZlcnNpb24HdmVjX21hcAd2ZXJzaW9uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAAIDFQgFEwsIAggDCAMlDQECARUIBAICAxUIBCUNEwsIAggDCAMCDgEOAA4AAQAAAwsLADgABAQFCAsBAQcAJwsBOAECAQEAAA8rDgFBEAwGCgYOAkEQIQQJBQ8LAAELAwEHAScGAAAAAAAAAAAMBQsACwM4AgwECgUKBiMEKQUaDQQOAQoFQhAUDgIKBUIQFDgDCwUGAQAAAAAAAAAWDAUFFQsEAgIBBAADCAsACgE4AgsBLhESOAQCAwEEABQYCgA3ABRIAQAWCgA2ABUKADcAFAwBCgA3ARQMAgsANwIRDwsBCwI5ADgFAgQBBAADBQsACwELAjgDAgUBBAAYJg4BQRAMBAoEDgJBECEECQUNCwABBwEnBgAAAAAAAAAADAMKAwoEIwQjBRQKAA4BCgNCEBQOAgoDQhAUOAMLAwYBAAAAAAAAABYMAwUPCwABAgYBBAADCwoANgEOATgGAQELAAsBCwI4AwIHAQQAAwcLADYBDgE4BgEBAggBAAADAwsAOAcCCQEAAAMECwA3ABQCCgEAAAMDCwA3AQILAAAAHAwLABEODAEOAREPOQE4CAsBOAlIAAA5AgIMAAAAAwYLADYBCwELAjgKAgACAAEAAAAOAQ4CDgAHZWQyNTUxOWqhHOsLBgAAAAYBAAIDAgUFBwwHExcIKiAMSgQAAAABAAEAAwYKAgYKAgYKAgEBB2VkMjU1MTkOZWQyNTUxOV92ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgABAgAAB2dyb3RoMTbNBqEc6wsGAAAACgEAAgICEAMSMgVETAeQAe0CCP0DIAadBB4KuwQgDNsEtAENjwYOAAoAAAcAAAEHAAADBwAAAgcAAAUAAQAABgABAAAQAgMAABEDBAAADwUGAAAOBQcAAAwIAwAADQkDAAASCgsAABMMCwAAAQgABAoCCgIKAgoCAQgBAQoKAgEKAgEIAgEIAwIGCAAGCgICAgYKAgQGCAAGCAEGCAIGCAMBAQcCBgoCBgoCBgoCBgoCBgoCBgoCBUN1cnZlFFByZXBhcmVkVmVyaWZ5aW5nS2V5C1Byb29mUG9pbnRzEVB1YmxpY1Byb29mSW5wdXRzFmFscGhhX2cxX2JldGFfZzJfYnl0ZXMIYmxzMTIzODEFYm4yNTQFYnl0ZXMVZGVsdGFfZzJfbmVnX3BjX2J5dGVzFWdhbW1hX2cyX25lZ19wY19ieXRlcwdncm90aDE2AmlkFXByZXBhcmVfdmVyaWZ5aW5nX2tleR5wcmVwYXJlX3ZlcmlmeWluZ19rZXlfaW50ZXJuYWwXcHJvb2ZfcG9pbnRzX2Zyb21fYnl0ZXMecHVibGljX3Byb29mX2lucHV0c19mcm9tX2J5dGVzDnB2a19mcm9tX2J5dGVzDHB2a190b19ieXRlcxR2ZXJpZnlfZ3JvdGgxNl9wcm9vZh12ZXJpZnlfZ3JvdGgxNl9wcm9vZl9pbnRlcm5hbBV2a19nYW1tYV9hYmNfZzFfYnl0ZXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAACAQsCAQIEFAoCBAoCCQoCCAoCAgIBBwoCAwIBBwoCAAEAAAADMQASAAIBAQAAAAMxARIAAgIBAAAABgsACwELAgsDEgECAwEAAAQYQAUAAAAAAAAAAAwBDQEOABAAFEQFDQEOABABFEQFDQEOABACFEQFDQEOABADFEQFCwECBAEAAAADCwASAgIFAQAAAAMLABIDAgYBAAAABgsAEAQUCwERBwIHAAIACAEAAAARCwAQBBQKARAACgEQAQoBEAILARADCwIQBQsDEAYRCQIJAAIAAQABAQECAQMAAAIAAwAAB3BhY2thZ2X/DaEc6wsGAAAACwEADgIOJAMytwEE6QEKBfMBdgfpAv4ECOcHQAanCF0KhAkwDLQJgQQNtQ0UACQBCgEyACEAMAAxADMAAQwAAAYMAAAIAAAABwAAAQIHAAIEBwADAAcAAwUEAAUDAgAADgABAQIADwACAQIADAECAAAWAwQBAAAVAwQBAAAnAwUAACgDBQAANAYHAAA2BggAADUGCQAALgoHAAAvCgkAACkLBwAAKgsHAAAtCgwAABECCQAACQIJAAATAgkAACINAgAAIw0CAAAeDgIAAAsPEAAAEBECAAArEgIAAhcCEwEAAhgYGQACGRgZAAMSFwIAAxoVBwEIAxsbBwADHB8bAAMgFhcABCYcAgEMBSwaGwAGHRUEAQIiFBgUABQgARwOAgkABwgIAQgAAAEGCAABAQEGCAQBBggBAQgGAQMBAgEGCAIBBggDAQYKAgEHCAEBCAEDBwgBAgoCAQgCAgcIAQgDAgcIAQIBCAUBCQABBgkAAQcICAEIBwEGCAUBCAQBBggIAQUCCQAFAgEIBQIIBggGAQYIBgJJRAlQdWJsaXNoZXIGU3RyaW5nCVR4Q29udGV4dAhUeXBlTmFtZQNVSUQKVXBncmFkZUNhcA5VcGdyYWRlUmVjZWlwdA1VcGdyYWRlVGlja2V0D2FkZGl0aXZlX3BvbGljeQVhc2NpaRFhdXRob3JpemVfdXBncmFkZQ5idXJuX3B1Ymxpc2hlcgNjYXAFY2xhaW0OY2xhaW1fYW5kX2tlZXAOY29tbWl0X3VwZ3JhZGURY29tcGF0aWJsZV9wb2xpY3kGZGVsZXRlD2RlcF9vbmx5X3BvbGljeQZkaWdlc3QLZnJvbV9tb2R1bGUMZnJvbV9wYWNrYWdlA2dldAtnZXRfYWRkcmVzcwpnZXRfbW9kdWxlAmlkD2lkX2Zyb21fYWRkcmVzcw1pZF90b19hZGRyZXNzE2lzX29uZV90aW1lX3dpdG5lc3MObWFrZV9pbW11dGFibGULbW9kdWxlX25hbWUDbmV3Bm9iamVjdBZvbmx5X2FkZGl0aXZlX3VwZ3JhZGVzEW9ubHlfZGVwX3VwZ3JhZGVzB3BhY2thZ2UGcG9saWN5D3B1YmxpY190cmFuc2ZlchBwdWJsaXNoZWRfbW9kdWxlEXB1Ymxpc2hlZF9wYWNrYWdlC3JlY2VpcHRfY2FwD3JlY2VpcHRfcGFja2FnZQhyZXN0cmljdAZzZW5kZXINdGlja2V0X2RpZ2VzdA50aWNrZXRfcGFja2FnZQ10aWNrZXRfcG9saWN5CHRyYW5zZmVyCnR4X2NvbnRleHQJdHlwZV9uYW1lBXR5cGVzD3VwZ3JhZGVfcGFja2FnZQ51cGdyYWRlX3BvbGljeQd2ZXJzaW9uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAgEAAgGAAgHABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAxoIByQIBB8IBAECBBoIByQIBjYDJQICAgQNCAYkCAYlAhQKAgMCAg0IBiQIBgABAAATEg4AOAAEBAUICwEBBwAnOAEMAgsBER8OAhEZDgIRGhIAAgEBAAACCAsACgE4AgsBLhEhOAMCAgEAAAIGCwATAAEBERsCAwEAABMJOAEMAQ4BERkLABAAFCECBAEAAB0XOAEMAg4CERkKABAAFCEEEQ4CERoLABABFCEMAQUVCwABCQwBCwECBQEAAAIDCwAQAQIGAQAAAgMLABAAAgcBAAACBAsAEAIUAggBAAACBAsAEAMUAgkBAAACBAsAEAQUAgoBAAACBAsAEAUUAgsBAAACBAsAEAYUAgwBAAACBAsAEAcUAg0BAAACBAsAEAgUAg4BAAACAwsAEAkCDwEAAAICBwUCEAEAAAICBwYCEQEAAAICBwcCEgEEAAIECwAHBhEXAhMBBAACBAsABwcRFwIUAQQAAgcLABMBAQEBERsCFQEAAB4pBwgRHQwDCgAQAhQKAyIECgUOCwABBwInCgEKABAEFCYEFQUZCwABBwEnCgAQAhQMBAsDCgAPAhULAC44BAsECwELAhICAhYBAAAeJwsBEwMMAwwCCgAuOAQLAiEECwUPCwABBwQnCgAQAhEeBwghBBYFGgsAAQcDJwsDCgAPAhUKABADFAYBAAAAAAAAABYLAA8DFQIXAAAAAhAKABAEFAoBJQQHBQsLAAEHAScLAQsADwQVAgABAAIBAQECAQMCAQICAwADAQIDAAd2ZWNfbWFwuA2hHOsLBgAAAA0BAAYCBhYDHKgBBMQBHAXgAf4BB94DmQII9wVABrcGMgrpBhUL/gYEDIIH6wUN7QwGDvMMBgAeARUBHwACBwIBAAAAAAAHAgEAAAABAQcBAAAABwABAgEAAA4CAAIBAAAXAwQCAQAAFgUEAgEAAA0DBgIBAAAIBwgCAQAAHAcJAgEBAAMHCgIBAAAaCwwCAQAAEAsKAgEAAAUBAAIBAAAPAQ0CAQAAEwsOAgEAAAwHDwIBAAALBwwCAQAACRARAgEAAAoSEwIBAAAYEgQCAQABBhsYAQABERwKAQABFAAbAQABGxgbAQACEBkKAQACFxcYAQACGR8AAQAHBA4EFxQWFAUEFRoUGg0EEwwIBBgUFQwUDBIMAAELAAIJAAkBAwcLAAIJAAkBCQAJAQIHCwACCQAJAQYJAAIJAAkBAQcLAAIJAAkBAQcJAQIGCwACCQAJAQYJAAEGCQEBCwIBCQEBAQEGCwACCQAJAQEDAgoJAAoJAQEKCQABCwIBAwIGCwACCQAJAQMCBgkABgkBAgcLAAIJAAkBAwIGCQAHCQEBCwECCQAJAQEGCQACBgkAAwIHCgkAAwEJAAEGCgkAAQkBAQsCAQkAAQYLAgEJAAEKCwECCQAJAQcKCwECCQAJAQMJAAoJAAMJAQoJAQEHCgkABAYLAQIJAAkBAwoJAAMCAwMBBgsBAgkACQEBBwsBAgkACQEFRW50cnkGT3B0aW9uBlZlY01hcAhjb250YWlucwhjb250ZW50cw1kZXN0cm95X2VtcHR5DGRlc3Ryb3lfc29tZQVlbXB0eQNnZXQQZ2V0X2VudHJ5X2J5X2lkeBRnZXRfZW50cnlfYnlfaWR4X211dAdnZXRfaWR4C2dldF9pZHhfb3B0B2dldF9tdXQGaW5zZXJ0EGludG9fa2V5c192YWx1ZXMIaXNfZW1wdHkHaXNfc29tZQNrZXkEa2V5cwRub25lBm9wdGlvbgNwb3AGcmVtb3ZlE3JlbW92ZV9lbnRyeV9ieV9pZHgHcmV2ZXJzZQRzaXplBHNvbWUHdHJ5X2dldAV2YWx1ZQd2ZWNfbWFwBnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAACAQQKCwECCQAJAQECAhIJAB0JAQAEAQQAAQAAAANAFAAAAAAAAAAAOQACAQEAABUUCgAOAQwDLgsDOAAgBAkFDQsAAQcAJwsANgALAQsCOQFEFAICAQAAFg0KAAsBDAIuCwI4AQwDCwA2AAsDOAI6AQIDAQAAAA8KADcAOAMgBAYFCgsAAQcEJwsANgBFFDoBAgQBAAAWDQoACwEMAi4LAjgBDAMLADYACwNDFDYBAgUBAAAMCgoACwE4AQwCCwA3AAsCQhQ3AQIGAQAACRMKAAoBOAAECwsACwE4BBQ4BQwCBRELAAELAQE4BgwCCwICBwEAAA8HCwALATgHDAIOAjgIAggBAAAABAsANwBBFAIJAQAAAAULADgJBgAAAAAAAAAAIQIKAQAAHQwLADoADAEOATgDBAcFCQcCJwsBRhQAAAAAAAAAAAILAQAAHigLADoADAENATgKBgAAAAAAAAAADAIOAUEUDAVAGAAAAAAAAAAADARAGgAAAAAAAAAADAcKAgoFIwQjBRMNAUUUOgEMBgwDDQQLA0QYDQcLBkQaCwIGAQAAAAAAAAAWDAIFDgsBRhQAAAAAAAAAAAsECwcCDAEAACAgBgAAAAAAAAAADAIKADcAQRQMBEAYAAAAAAAAAAAMAwoCCgQjBBwFDQoANwAKAkIUDAENAwsBNwIURBgLAgYBAAAAAAAAABYMAgUICwABCwMCDQEAACEkBgAAAAAAAAAADAIKADgJDAMKAgoDIwQeBQoKADcACgJCFDcCCgEhBBkLAAELAQELAjgLAgsCBgEAAAAAAAAAFgwCBQULAAELAQE4DAIOAQAADw0LAAsBOAcMAg4COAgECAUKBwEnCwI4DQIPAQAAIhQKAQoAOAkjBAYFCgsAAQcDJwsANwALAUIUDAIKAjcCCwI3AQIQAQAAIxUKAQoALjgJIwQHBQsLAAEHAycLADYACwFDFAwCCgI3AgsCNgECEQEAAAARCgEKAC44CSMEBwULCwABBwMnCwA2AAsBOAI6AQIAAAEBAQAABAEEAgQAB3ZlY19zZXStBqEc6wsGAAAADQEABgIGDAMSYARyFAWGAVoH4AGfAQj/AkAGvwMUCtMDBwvaAwIM3AORAg3tBQIO7wUCABIBDQETAAEHAQMAAQAHAQAAAAUAAQEDAA8CAQEDAAgDAAEDAA4EAAEDAAIFBgEDABAHCAEDAAoHBgEDAAkBCQEDAAcFCgEDAAYFCAEDAQQQAgEAAQsOBgEAAQwAEAEAARECEAEAAg4NAgEAAg8CCQEADwIEAgkCDgIIAgsIBQINCAwICggAAQsAAQkAAQkAAgcLAAEJAAkAAgcLAAEJAAYJAAIGCwABCQAGCQABAQEGCwABCQABAwEKCQABCwEBAwEGCQACBgkAAwIHCgkAAwEGCwEBCQACAwMBCwEBCQAGT3B0aW9uBlZlY1NldAhjb250YWlucwhjb250ZW50cwxkZXN0cm95X3NvbWUFZW1wdHkHZ2V0X2lkeAtnZXRfaWR4X29wdAZpbnNlcnQJaW50b19rZXlzCGlzX2VtcHR5B2lzX3NvbWUEbm9uZQZvcHRpb24GcmVtb3ZlCXNpbmdsZXRvbgRzaXplBHNvbWUHdmVjX3NldAZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAAAAgEDCgkAAAIAAQAAAANAAgAAAAAAAAAAOQACAQEAAAAECwA4ADkAAgIBAAALEgoADgEMAi4LAjgBIAQJBQ0LAAEHACcLADYACwFEAgIDAQAADA0KAAsBDAIuCwI4AgwDCwA2AAsDOAMBAgQBAAAKBwsACwE4BAwCDgI4BQIFAQAAAAQLADcAQQICBgEAAAAFCwA4BgYAAAAAAAAAACECBwEAAAADCwA6AAIIAAAADyMGAAAAAAAAAAAMAgoAOAYMAwoCCgMjBB0FCgoANwAKAkICCgEhBBgLAAELAQELAjgHAgsCBgEAAAAAAAAAFgwCBQULAAELAQE4CAIJAAAACg0LAAsBOAQMAg4COAUECAUKBwEnCwI4CQIAAAACAAhibHMxMjM4MZQBoRzrCwYAAAAGAQACAwIKBQwMBxg4CFAgDHAIAAAAAgABAAABAAEAAwYKAgYKAgYKAgEBCGJsczEyMzgxFmJsczEyMzgxX21pbl9wa192ZXJpZnkXYmxzMTIzODFfbWluX3NpZ192ZXJpZnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgABAgABAQIAAAhlY2RzYV9rMdQBoRzrCwYAAAAHAQACAwIPBREcBy1ACG0gBo0BGgynAQwAAQACAAEAAAACAQAAAwMEAAMGCgIGCgICAQoCAQYKAgQGCgIGCgIGCgICAQERZGVjb21wcmVzc19wdWJrZXkIZWNkc2FfazETc2VjcDI1NmsxX2VjcmVjb3ZlchBzZWNwMjU2azFfdmVyaWZ5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAIBAAIBAQABAgABAQIAAgECAAAIZWNkc2FfcjG0AaEc6wsGAAAABwEAAgMCCgUMGAckLghSIAZyGgyMAQgAAAABAAEAAAICAwADBgoCBgoCAgEKAgQGCgIGCgIGCgICAQEIZWNkc2FfcjETc2VjcDI1NnIxX2VjcmVjb3ZlchBzZWNwMjU2cjFfdmVyaWZ5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAIBAAIBAQABAgABAQIAAAh0cmFuc2ZlcvgCoRzrCwYAAAAIAQACAwI2BDgGBT4IB0aQAQjWASAG9gEKDIACUgAHAAcAAQEIAAQAAQEMAAACAQEIAAICAQEMAAUCAQEIAAMCAQEMAAECAQEIAAYCAQEIAAgAAQEICAIGAgcCAgkABQABCQANZnJlZXplX29iamVjdBJmcmVlemVfb2JqZWN0X2ltcGwUcHVibGljX2ZyZWV6ZV9vYmplY3QTcHVibGljX3NoYXJlX29iamVjdA9wdWJsaWNfdHJhbnNmZXIMc2hhcmVfb2JqZWN0EXNoYXJlX29iamVjdF9pbXBsCHRyYW5zZmVyDXRyYW5zZmVyX2ltcGwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAAAAQAAAQQLAAsBOAACAQEAAAEECwALATgAAgIBAAABAwsAOAECAwEAAAEDCwA4AQIEAQAAAQMLADgCAgUBAAABAwsAOAICBgMCAAcDAgAIAwIAAAl0YWJsZV92ZWOyBqEc6wsGAAAADQEABgIGEgMYZwR/FAWTAYoBB50CnwEIvAMgBtwDFArwAwoL+gMCDPwD9QEN8QUCDvMFAgARABAAEgABBAEEAQEADAIHAQQBAgICAAAIAAEBBAAPAgEBBAAKAwQBBAAJAwUBBAAEBgcBBAANCAkBBAAFCgsBBAAMDA0BBAAHAQkBBAEDEwkCBwQBBBESAgcEAQUUFQIHBAEHDwkCBwQBChAEAgcEAQsADwIHBAEOFBYCBwQODgANBQ0NDgINCg4JDgsODw4MDgEHCAIBCwABCQACCQAHCAIBBgsAAQkAAQMBAQIGCwABCQADAQYJAAIHCwABCQAJAAACBwsAAQkAAwEHCQABBwsAAQkAAQkAAgMJAAELAQIJAAkBAQYLAQIJAAkBAgYLAQIJAAkBCQABBgkBAwcLAQIJAAkBCQAJAQIHCwECCQAJAQkAAQcJAQEJAQVUYWJsZQhUYWJsZVZlYwlUeENvbnRleHQDYWRkBmJvcnJvdwpib3Jyb3dfbXV0CGNvbnRlbnRzDWRlc3Ryb3lfZW1wdHkFZW1wdHkIaXNfZW1wdHkGbGVuZ3RoA25ldwhwb3BfYmFjawlwdXNoX2JhY2sGcmVtb3ZlCXNpbmdsZXRvbgV0YWJsZQl0YWJsZV92ZWMKdHhfY29udGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAAAAgEGCwECAwkAAA0AAQAACQQLADgAOQACAQEAAAEICwE4AQwCDQILADgCCwICAgEAAAkECwA3ADgDAgMBAAAJBQsAOAQGAAAAAAAAAAAhAgQBAAAJDwoAOAQKASQEBgUKCwABBwAnCwA3AAsBOAUCBQEAAAQKCgAuOAQMAgsANgALAgsBOAYCBgEAAAkQCgAuOAQKASQEBwULCwABBwAnCwA2AAsBOAcCBwEAAAQUCgAuOAQMAQoBBgAAAAAAAAAAJAQJBQ0LAAEHACcLADYACwEGAQAAAAAAAAAXOAgCCAEAAAkMDgA4BAYAAAAAAAAAACEEBgUIBwEnCwA6ADgJAgAAAA0ACXZlcnNpb25lZP4FoRzrCwYAAAALAQAIAggUAxxVBHEKBXthB9wB7AEIyAMgBugDCgryAxAMggTFAQ3HBQQAFwALABAAFAAEDAAAAwAAAgAHAAICBAADAQIAAAgAAQEEABYCAwAADQIEAQQADgUGAQQAEwUHAQQAFQgJAQQACgEKAQQBBQ4JAgcEAQYPEAIHBAEHERICBwQBEhETAgcEAgkMCQACDAQUAQgCDwsMAAcNCA0JDQoNDAEDAwkABwgEAQgAAQYIAAEDAQYJAAEHCAABBwkAAgkACAEEBwgAAwkACAEAAQkAAQcIBAEIAwIDCQADBwgDCQAJAQIGCAMJAAEGCQECBwgDCQABBwkBAQkBAQgCAwgDCQADAklECVR4Q29udGV4dANVSUQQVmVyc2lvbkNoYW5nZUNhcAlWZXJzaW9uZWQDYWRkBmJvcnJvdwpib3Jyb3dfbXV0BmNyZWF0ZQZkZWxldGUHZGVzdHJveQ1keW5hbWljX2ZpZWxkAmlkCmxvYWRfdmFsdWUObG9hZF92YWx1ZV9tdXQDbmV3Bm9iamVjdAtvbGRfdmVyc2lvbgZyZW1vdmUYcmVtb3ZlX3ZhbHVlX2Zvcl91cGdyYWRlCnR4X2NvbnRleHQHdXBncmFkZQd2ZXJzaW9uCXZlcnNpb25lZAx2ZXJzaW9uZWRfaWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAAAAgIMCAMWAwECAhgIAhEDAAEAAAEMCwIRDQoAEgAMAw0DDwALAAsBOAALAwIBAQAACQQLABABFAICAQAACQcKABAACwAQARQ4AQIDAQAACQcKAA8ACwAQARQ4AgIEAQAACQ4KAA8ACgAQARQ4AwoALjgECwAQARQSAQIFAQAAAyALAxMBDAQKAC44BCEECQUNCwABBwAnCwQKASMEEgUWCwABBwAnCgAPAAoBCwI4AAsBCwAPARUCBgEAABUMCwATAAwDDAENAQsDOAMMAgsBEQsLAgIAAAABAApvYmplY3RfYmFn6QahHOsLBgAAAAsBAAoCChYDIHwEnAEOBaoBWAeCAucBCOkDQAapBAoKswQIDLsE9QENsAYEABQBFQAMABMAGAABDAABAgcBAAADAAcAAwQEAAQDAgAAEgABAAAFAgMCBwwABgQFAgcMAAcGBwIHDAAWBggCBwwACAQJAQcACQQJAgcMABEKCwAAEAoJAAALAQMAABkEDAEHAgUPAwIHDAIGEAUCBwwCBxEHAgcMAg0QCQEHAg4QCQIHDAIPEAwBBwIWEQgCBwwDCg0DAAMSAA0ACw4MDg0OEQ4OEg8OEBIBBwgEAQgAAwcIAAkACQEAAgYIAAkAAQYJAQIHCAAJAAEHCQEBCQEBAQEGCAABAwELAQEIAgEIAwIJAAkBAwcIAwkACQECBggDCQACBwgDCQABCQACCAMDAklECU9iamVjdEJhZwZPcHRpb24JVHhDb250ZXh0A1VJRANhZGQGYm9ycm93CmJvcnJvd19tdXQIY29udGFpbnMSY29udGFpbnNfd2l0aF90eXBlBmRlbGV0ZQ1kZXN0cm95X2VtcHR5FGR5bmFtaWNfb2JqZWN0X2ZpZWxkB2V4aXN0c18QZXhpc3RzX3dpdGhfdHlwZQJpZAhpc19lbXB0eQZsZW5ndGgDbmV3Bm9iamVjdApvYmplY3RfYmFnBm9wdGlvbgZyZW1vdmUEc2l6ZQp0eF9jb250ZXh0CHZhbHVlX2lkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAAAAgIPCAMXAwABAAADBQsAERMGAAAAAAAAAAASAAIBAQAAAw4KAA8ACwELAjgACgAQARQGAQAAAAAAAAAWCwAPARUCAgEAAAMFCwAQAAsBOAECAwEAAAMFCwAPAAsBOAICBAEAAAgPCgAPAAsBOAMMAgoAEAEUBgEAAAAAAAAAFwsADwEVCwICBQEAAAMFCwAQAAsBOAQCBgEAAAMFCwAQAAsBOAUCBwEAAAMECwAQARQCCAEAAAMGCwAQARQGAAAAAAAAAAAhAgkBAAATDgsAEwAMAgwBCwIGAAAAAAAAAAAhBAkFCwcAJwsBERICCgEAAAMFCwAQAAsBOAYCAAAAAQAKdHhfY29udGV4dPkCoRzrCwYAAAAKAQACAgIEAwYeBSQUBzhoCKABIAbAARQK1AEODOIBYA3CAgoABwAAAgAABgABAAACAAIAAAMAAgAABAMBAAAFAAIAAAEEAQABBggAAQUBAwEHCAACCgIDAAIFAwlUeENvbnRleHQJZGVyaXZlX2lkBWVwb2NoEmVwb2NoX3RpbWVzdGFtcF9tcxRmcmVzaF9vYmplY3RfYWRkcmVzcwtpZHNfY3JlYXRlZAZzZW5kZXIKdHhfY29udGV4dAd0eF9oYXNoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCCAAAAAAAAAAAwgAAAAAAAAAAAACBQYFCAoCAgMDAwUDAAEAAAUECwAQABQCAQEAAAUECwAQARQCAgEAAAUECwAQAhQCAwEAAAYSCgAQAxQMAgoAEAQUCgIRBQwBCwIGAQAAAAAAAAAWCwAPAxULAQIEAAAABQQLABADFAIFAAIAAAAAAgADAAQAAQAMbGlua2VkX3RhYmxlkQ2hHOsLBgAAAA0BAAoCCh4DKNQBBPwBHAWYArwBB9QDzQIIoQZABuEGFAr1BiYLmwcEDJ8HlwUNtgwODsQMDgAYAR0ADgAcACgAAAwCBwAEAQABBAIHAAQAAQIHAQAAAwQEAAQDAgAAGQABAgcEABECAwIHBAAGAgMCBwQAIgQFAgcEACEEBQIHBAAHBgcCBwQACAgJAgcEACAGAwIHBAAaBgMCBwQAIwgKAgcEAB8LDAIHBAAeCwwCBwQACQYNAgcEABcCDgIHBAAUAg0CBwQACwEFAgcEAA0BBQIHBgEHAxkBAAEMERABAAEQEwUBAAEVAw0BAAEWAw0BAAEbBREBAAElEBEBAAEmExEBAAIFFgUCBwQCBxcHAgcEAggVCQIHBAIPFw0CBwQCIxUKAgcEAwoPBQADGQAPABYQGBAUEBMQFRASEBcQGxQZFBoUHRQREAkMHBQBBwgEAQsAAgkACQEBBgsAAgkACQEBBgsCAQkAAwcLAAIJAAkBCQAJAQACBgsAAgkACQEJAAEGCQECBwsAAgkACQEJAAEHCQEBCQEBBwsAAgkACQECCQAJAQEBAQMBCAMBCQABCwIBCQAFCwIBCQALAgEJAAsCAQkACQALAgEJAAIHCwIBCQAJAAIJAAsBAgkACQECBwgDCQADBwgDCQAJAQIGCAMJAAMLAgEJAAsCAQkACQEBBgkAAggDAwtMaW5rZWRUYWJsZQROb2RlBk9wdGlvbglUeENvbnRleHQDVUlEA2FkZARiYWNrBmJvcnJvdwpib3Jyb3dfbXV0CGNvbnRhaW5zBmRlbGV0ZQ1kZXN0cm95X2VtcHR5DGRlc3Ryb3lfc29tZQRkcm9wDWR5bmFtaWNfZmllbGQQZXhpc3RzX3dpdGhfdHlwZQRmaWxsBWZyb250BGhlYWQCaWQIaXNfZW1wdHkHaXNfbm9uZQdpc19zb21lBmxlbmd0aAxsaW5rZWRfdGFibGUDbmV3BG5leHQEbm9uZQZvYmplY3QGb3B0aW9uCHBvcF9iYWNrCXBvcF9mcm9udARwcmV2CXB1c2hfYmFjawpwdXNoX2Zyb250BnJlbW92ZQRzaXplBHNvbWUMc3dhcF9vcl9maWxsBHRhaWwKdHhfY29udGV4dAV2YWx1ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAACBBMIAyQDEgsCAQkAJwsCAQkAAQIDIAsCAQkAGgsCAQkAKQkBAAwBDAABAAAFBwsAER8GAAAAAAAAAAA4ADgAOQACAQEAAAUDCwA3AAICAQAABQMLADcBAgMBAAASNgoANgAKATgBDAUKADcBOAIEDQoANgEKATgDOAAMBw4FOAQEIQsFOAUMBgoBOAYKADYCCgY4BzYDFQsGOAYMAwUjOAAMAwsDDAQKADYCCwELBwsECwI5ATgICgA3BBQGAQAAAAAAAAAWCwA2BBUCBAEAABI2CgA3ADgCBAgKADYACgE4AwoANgEKATgBDAUOBTgEBB8LBTgFDAYKATgGCgA2AgoGOAc2BRULBjgGDAMFITgADAMLAwwHOAAMBAoANgILAQsHCwQLAjkBOAgKADcEFAYBAAAAAAAAABYLADYEFQIFAQAABQYLADcCCwE4CTcGAgYBAAAFBgsANgILATgHNgYCBwEAAAUGCwA3AgsBOAk3AwIIAQAABQYLADcCCwE4CTcFAgkBAAAYQQoANgIKATgKOgEMBAwCDAMKADcEFAYBAAAAAAAAABcKADYEFQ4DOAQEHAoCCgA2Ag4DOAsUOAc2BRUOAjgEBCgKAwoANgIOAjgLFDgHNgMVCgA3ADgLDgEhBDILAgoANgAVCgA3ATgLDgEhBD0LAwsANgEVBT8LAAELBAIKAQAAEBMKADcAOAQEBQUJCwABBwEnCgA3ADgLFAwBCgELAAsBOAwCCwEAABATCgA3ATgEBAUFCQsAAQcBJwoANwE4CxQMAQoBCwALATgMAgwBAAAFBQsANwILATgNAg0BAAAFBAsANwQUAg4BAAAFBgsANwQUBgAAAAAAAAAAIQIPAQAAGhALADoAAQEMAgwBCwIGAAAAAAAAAAAhBAsFDQcAJwsBER4CEAEAAAUHCwA6AAEBAREeAgACAAMAAAEAAAEBAQECAAwBDAIMAwwEDAUMBgwADG9iamVjdF90YWJsZd8GoRzrCwYAAAANAQAKAgoaAyR4BJwBDAWoAXEHmQLHAQjgA0AGoAQKCqoECAuyBAIMtATmAQ2aBgQOngYEABIBEwALABEAFgABDAIHAQwBAQIHAQAAAwAHAAMEBAAEAwIAABAAAQIHDAAFAgMCBwwABgQFAgcMAAcGBwIHDAAUBggCBwwACAQJAgcMAA8KCwIHDAAOCgkCBwwACgEDAgcMABcEDAIHDAIFDwMCBwwCBhAFAgcMAgcRBwIHDAIMEAkBBwINEAwBBwIUEQgCBwwDCQ0DAAMQAA0ACg4LDgwODw4NEg4SAQcIBAELAAIJAAkBAwcLAAIJAAkBCQAJAQACBgsAAgkACQEJAAEGCQECBwsAAgkACQEJAAEHCQEBCQEBAQEGCwACCQAJAQEDAQsBAQgCAQgDAgkACQEDBwgDCQAJAQIGCAMJAAIHCAMJAAEJAAIIAwMCSUQLT2JqZWN0VGFibGUGT3B0aW9uCVR4Q29udGV4dANVSUQDYWRkBmJvcnJvdwpib3Jyb3dfbXV0CGNvbnRhaW5zBmRlbGV0ZQ1kZXN0cm95X2VtcHR5FGR5bmFtaWNfb2JqZWN0X2ZpZWxkB2V4aXN0c18CaWQIaXNfZW1wdHkGbGVuZ3RoA25ldwZvYmplY3QMb2JqZWN0X3RhYmxlBm9wdGlvbgZyZW1vdmUEc2l6ZQp0eF9jb250ZXh0CHZhbHVlX2lkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAAAAgINCAMVAwAOAAEAAAMFCwAREQYAAAAAAAAAADkAAgEBAAADDgoANgALAQsCOAAKADcBFAYBAAAAAAAAABYLADYBFQICAQAAAwULADcACwE4AQIDAQAAAwULADYACwE4AgIEAQAACA8KADYACwE4AwwCCgA3ARQGAQAAAAAAAAAXCwA2ARULAgIFAQAAAwULADcACwE4BAIGAQAAAwQLADcBFAIHAQAAAwYLADcBFAYAAAAAAAAAACECCAEAABMOCwA6AAwCDAELAgYAAAAAAAAAACEECQULBwAnCwEREAIJAQAAAwULADcACwE4BQIAAAABAA4BDgANZHluYW1pY19maWVsZJYKoRzrCwYAAAAOAQAGAgYWAxyFAQShARgFuQGoAQfhAoEDCOIFQAaiBigKygYMC9YGAgzYBusCDcMJBg7JCQgP0QkCAAsBGgAZAAAIAgcABAABAgcBAAACAQcAAgMEAAAEAAECBwQABgIDAgcEAAkEBQIHBAAbBAYCBwQADQIHAQcAHQQIAgcEAA4CBwIHBAAPAgkBBwAQBAoBBwATCwwBBwAFCwEBCAAHCQ0BCAAICg4BCAAcDxABCAARDwcAABIPBwEIARgBGAEAAR4QGAEAAgoTAQACFRwMAAIXDBMAAh8SDAAJEAoVCxUMFQ0VBBADFBEGEAYPFQsaDBoDBwgDCQAJAQACBggDCQABBgkBAgcIAwkAAQcJAQEJAQEBAQsBAQkBAgYIAwUCBwgDBQIFCQABBQEGCQABBwkAAgUFAQkAAwsAAgkACQEFBQEGCAMBCAMCCQAJAQELAAIJAAkBAwUFCQECCQALAQEJAQELAQEJAAQGCwACCQAIAgUGCAMGCAIBCwACCQAIAgIJAAgCAQYIAgQHCwACCQAIAgUHCAMHCAIFRmllbGQCSUQGT3B0aW9uA1VJRANhZGQQYWRkX2NoaWxkX29iamVjdAZib3Jyb3cTYm9ycm93X2NoaWxkX29iamVjdBdib3Jyb3dfY2hpbGRfb2JqZWN0X211dApib3Jyb3dfbXV0BmRlbGV0ZQ1keW5hbWljX2ZpZWxkFGR5bmFtaWNfb2JqZWN0X2ZpZWxkB2V4aXN0c18QZXhpc3RzX3dpdGhfdHlwZQpmaWVsZF9pbmZvDmZpZWxkX2luZm9fbXV0EGhhc19jaGlsZF9vYmplY3QYaGFzX2NoaWxkX29iamVjdF93aXRoX3R5EWhhc2hfdHlwZV9hbmRfa2V5AmlkDWlkX3RvX2FkZHJlc3MEbmFtZRFuZXdfdWlkX2Zyb21faGFzaARub25lBm9iamVjdAZvcHRpb24GcmVtb3ZlE3JlbW92ZV9jaGlsZF9vYmplY3QQcmVtb3ZlX2lmX2V4aXN0cwRzb21lDnVpZF90b19hZGRyZXNzBXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAAAAgMUCAMWCQAgCQEAFAABAAARGgsALhEVDAUKBQoBOAAMBAoFCgQRDiAEDgUQBwAnCwQRFAsBCwI5AAwDCwULAzgBAgEBAAAMCgoAERULATgADAILAAsCOAI3AAICAQAADAsKAC4RFQsBOAAMAgsACwI4AzYAAgMBAAAWEQsALhEVDAMKAwsBOAAMAgsDCwI4BDoADAQBERILBAIEAQAADwsLABEVDAMKAwsBOAAMAgsDCwIRDgIFAQAAFxMKAAoBDAIuCwI4BQQNCwALATgGOAcMAwURCwABOAgMAwsDAgYBAAAPCwsAERUMAwoDCwE4AAwCCwMLAjgJAgcDAAAZFgoAERULATgADAMLAAsDOAoMAgoCNwEMBAoCNwIBCwI3AwwFCwQLBRETAggDAAAdGAoALhEVCwE4AAwDCwALAzgLDAIKAjYBDAQKAjYCAQsCNgMMBQsECwUuERMCCQMCAAoDAgALAwIADAMCAA0DAgAOAwIADwMCAAACAAAAAQAUARsCGwAbAAwADnByaW9yaXR5X3F1ZXVl0AqhHOsLBgAAAA0BAAQCBAwDEDwETAoFVqcBB/0BuAEItQNABvUDDgqDBBILlQQEDJkE8wUNjAoEDpAKBAALARAAAQYBAgAAAAYBAgAABgABAQIACAIDAQIABAQFAQIABwMGAQIAAgcAAQIADQgFAQIABQkFAQIACQoLAQIBDA8NAQABDg8NAQAGDQkGBQ0IEAgNAQoLAQEJAAELAAEJAAEHCwABCQACAwkAAwcLAAEJAAMJAAABCwEBCQACCgMKCQACBwoLAQEJAAMDBwoLAQEJAAMDAQYLAAEJAAEKAwIDAwEJAAMDAwkAAgcKCQADAQMFAwMDCgsBAQkACQAFBwoLAQEJAAMHCgsBAQkAAwMNBwoLAQEJAAEDBwoLAQEJAAMBBwoLAQEJAAMHCgsBAQkAAwMDAwIDCgMFRW50cnkNUHJpb3JpdHlRdWV1ZQ5jcmVhdGVfZW50cmllcwdlbnRyaWVzBmluc2VydBVtYXhfaGVhcGlmeV9yZWN1cnNpdmUDbmV3CW5ld19lbnRyeQdwb3BfbWF4CnByaW9yaXRpZXMIcHJpb3JpdHkOcHJpb3JpdHlfcXVldWUGcmVtb3ZlFnJlc3RvcmVfaGVhcF9yZWN1cnNpdmULc3dhcF9yZW1vdmUFdmFsdWUGdmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAAKAwEAAAIBAwoLAQEJAAECAgoDDwkAAA0BDQABAAAMGA4AQQYMAgoCBgIAAAAAAAAAGgwBCgEGAAAAAAAAAAAkBBUFDAsBBgEAAAAAAAAAFwwBDQAKAgoBOAAFBwsAOQACAQEAAA4eCgA3AEEGDAEKAQYAAAAAAAAAACQECQUNCwABBwAnCgA2AAYAAAAAAAAAADgBOgEMAwwCCwA2AAsBBgEAAAAAAAAAFwYAAAAAAAAAADgACwILAwICAQAAEBEKADYACwELAjkBRAYKADcAQQYGAQAAAAAAAAAXDAMLADYACwM4AgIDAQAABQQLAAsBOQECBAEAABEoDgBBEAwDDgFBDQoDIQQJBQsGAAAAAAAAAAAnQAYAAAAAAAAAAAwFBgAAAAAAAAAADAIKAgoDIwQmBRQNAAYAAAAAAAAAADgDDAQNAQYAAAAAAAAAADgEDAYNBQsECwY5AUQGCwIGAQAAAAAAAAAWDAIFDwsFAgUAAAASLgoBBgAAAAAAAAAAIQQHCwABAgoBBgEAAAAAAAAAFwYCAAAAAAAAABoMBgoACgEMAwwCCgAKBgwFDAQLAi4LA0IGNwEUCwQuCwVCBjcBFCQEKwoACwEKBkcGCwALBjgCBS0LAAECBgAAABNuCgEGAAAAAAAAAAAhBAcLAAECCgIKASMEDAUQCwABBgEAAAAAAAAAJwoCBgIAAAAAAAAAGAYBAAAAAAAAABYMDQoNBgEAAAAAAAAAFgwPCgIMDgoNCgEjBDcKAAoNDAUMAwoACg4MBwwGCwMuCwVCBjcBFAsGLgsHQgY3ARQkDAgFOQkMCAsIBD0LDQwOCg8KASMEWAoACg8MCgwJCgAKDgwMDAsLCS4LCkIGNwEUCwsuCwxCBjcBFCQMBAVaCQwECwQEXgsPDA4KDgoCIgRrCgAKDgsCRwYLAAsBCw44AAVtCwABAgcBAAAUHAcBDAIGAAAAAAAAAAAMAQoBCgA3AEEGIwQYBQsNAgoANwAKAUIGNwEURBALAQYBAAAAAAAAABYMAQUECwABCwICAAABAAANAQ0AD3RyYW5zZmVyX3BvbGljefsRoRzrCwYAAAANAQAYAhhOA2bzAQTZAioFgwOWAweZBuUECP4KQAa+CzwK+gs3C7EMCgy7DOEEDZwREA6sERAAOwEvAT0AEwAVABwAHwAuADAAOQA8AEIACgABAAEABwwBAAEACAwBAAEACQMBAAEABQcBAgEBAwcBAAACDAcAAwAEAQABBAEMAQABBwIHAAcNBAAIBAwACQYCAAoLAgALDgcBAwAALQABAQAALAIDAQAAQwQFAQAAGQYFAQAAFgcAAQAAEQgJAwACBgAlCgsDAAIGABIMCQIAAgAQDQkCAAIAJg4PAgACADYQCQMAAgYAPg4RAQAAPxASAQAAKxMUAQAAMRMVAQAAIRMUAQABGiQYAQABKiMPAQACJAkWAQADQSUVAQADRAkfAQAEIiknAQAEMzUJAQAEOiYnAQAFDzEJAgcEBRQzNAIHBAUgMw8BBwU1Ny8CBwQGHRgJAQMHGBwJAAcnIhQBCAcsGxwAB0ARFAAIIxoPAQALFy0PAQMLHgkXAQMLKDIJAQMLKRcrAQMLOCwVAQMjFiEYHB0UHh4hERUQFRMeFx4VHiUWJhYiFgkuGDASLyQWGTAWHho2GzADCAkDCAkBCwABCQACBggLBwgNAgsBAQkACwIBCQAEBwsBAQkABgsCAQkACwUBAwcIDQELCAEIDAMLAQEJAAsCAQkABwgNAgYLAQEJAAsAAQkABAkBBwsBAQkABgsCAQkACQIAAgkBBgsBAQkAAQYJAgMJAQcLAQEJAAsIAQgMAgkBBwsAAQkAAQYLAQEJAAEBAgcLAQEJAAYLAgEJAAEGCAoBBwgKAQYLAAEJAAEICQEDAQgGAQsOAQkAAQkABQgKCw4BCAYLBwEIDAgKCAkBBggLAQcIDQEICgELAwEJAAEIDAELBwEJAAMDAwMBCwEBCQABBgkAAQYLBQEJAAELBQEJAAEGCwcBCQADBwsHAQkAAwcIDQELCAEJAAILBwEIDAgKAgsHAQkABwgNBwoIBggJCAkDCw4BCAYIBgMBCgkAAQYLDgEJAAIGCw4BCQAGCQACCQAJAQEJAQILBAEJAQkCAwcICgkACQECBwsOAQkACQACBggKCQABBgkBAgcLBwEJAAsIAQkAAQsEAQkBAgcICgkAB0JhbGFuY2UEQ29pbgJJRAZPcHRpb24JUHVibGlzaGVyB1J1bGVLZXkDU1VJDlRyYW5zZmVyUG9saWN5EVRyYW5zZmVyUG9saWN5Q2FwFVRyYW5zZmVyUG9saWN5Q3JlYXRlZA9UcmFuc2ZlclJlcXVlc3QJVHhDb250ZXh0CFR5cGVOYW1lA1VJRAZWZWNTZXQDYWRkC2FkZF9yZWNlaXB0CGFkZF9ydWxlDmFkZF90b19iYWxhbmNlB2JhbGFuY2UGYm9ycm93BGNvaW4PY29uZmlybV9yZXF1ZXN0CGNvbnRhaW5zBmRlbGV0ZRRkZXN0cm95X2FuZF93aXRoZHJhdwxkZXN0cm95X3NvbWULZHVtbXlfZmllbGQNZHluYW1pY19maWVsZARlbWl0BWVtcHR5BWV2ZW50B2V4aXN0c18EZnJvbQxmcm9tX2JhbGFuY2UMZnJvbV9wYWNrYWdlA2dldAhnZXRfcnVsZQhoYXNfcnVsZQJpZAZpbnNlcnQJaW50b19rZXlzB2lzX3NvbWUEaXRlbQNuZXcLbmV3X3JlcXVlc3QGb2JqZWN0Bm9wdGlvbgdwYWNrYWdlBHBhaWQJcG9saWN5X2lkA3B1dAhyZWNlaXB0cwZyZW1vdmULcmVtb3ZlX3J1bGUFcnVsZXMEc2l6ZQNzdWkEdGFrZQ90cmFuc2Zlcl9wb2xpY3kKdHhfY29udGV4dAl0eXBlX25hbWUDdWlkEHVpZF9tdXRfYXNfb3duZXIMdWlkX3RvX2lubmVyBXZhbHVlB3ZlY19zZXQId2l0aGRyYXcEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAMIBQAAAAAAAAAAAgQrCAkxAyEICTQLDgEIBgECAycIChMLBwEIDDcLDgEIBgICAicICjIICQMCAScICQQCARsBABgDGAEYAhgELwABAAAJBgsACwELAjgAOQACAQEAABkgCwA4AQQEBQgLAQEGAAAAAAAAAAAnCgERHwwFDgURIAwGCgY5ATgCCwUMAjgADAM4AwwECwILBAsDOQILAREfCwY5AwICAQAAIDEKAC44BAsBNwAUIQQJBQ8LAAELAwEHBCcOAjgFBCULAjgGDAYKBgoANwE4ByUEHAUiCwABCwMBBwUnCwYMBAUpCgA3ATgHDAQLBAwFCwA2AQsFCwM4CAIDAQAAKBsOADgEDgE3ABQhBAgFDAsCAQcEJwsBOgMBDAQLADoCAQwDER0LBBEdCwMLAjgJAgQBAAAqNAsBOgAMBgwDDAUMBAsGOAoMAg4CQRYMCAoICgA3AjgLIQQTBRcLAAEHACcKCAYAAAAAAAAAACQELgUcDQJFFgwHCgA3Ag4HOAwEJQUpCwABBwEnCwgGAQAAAAAAAAAXDAgFFwsAAQsECwULAwIFAQAACSIKAS44BAsCNwAUIQQJBQ0LAQEHBCcKAS44DSAEEwUXCwEBBwMnCgE2Awk5BAsDOA4LATYCOA84EAIGAQAACQYLATcDCTkEOBECBwEAAAkOCgEuOA0EBQUJCwEBBwInCwE2AQsCOBICCAEAAAkFCwE2BDgPOBACCQEAAAkGCwA3Awk5BDgTAgoBAAAJFAoALjgECwE3ABQhBAkFDQsAAQcEJwsANgMJOQQ4FAECCwEAAAkDCwA3AwIMAQAACRAKAC44BAsBNwAUIQQJBQ0LAAEHBCcLADYDAg0BAAAJBAsANwUUAg4BAAAJBAsANwYUAg8BAAAJBAsANwcUAgIBAQEBAgEAAAMAAAABAAIAGAEYAhgDGAQYBRgGGAcYABRkeW5hbWljX29iamVjdF9maWVsZNkHoRzrCwYAAAAKAQAIAggUAxyKAQSmARoFwAGDAQfDArICCPUEQAq1BQYLuwUCDL0F6QEACwEWAAoAFQADBwEAAAEBBwEAAAMABwADAgQAAAQAAQIHDAAGAgMCBwwACQQFAgcMABcEBgIHDAAMAgcBBwANAgcCBwwAEQIIAQcBFAEYAQABGQoYAQACBAABAgcEAgUSAQEIAgcPCwEIAggTFAEIAg0CBwIHBAIOAg8BBwIPBBMBBwIQFgcBCAIXBAYCBwQCGBYKAQgDEQsMAQgDEhEMAAMaEBEAEwYJDQ4OCgYLBg8ODAYSBhENDQ0QBgcMCAwDBwgDCQAJAQACBggDCQABBgkBAgcIAwkAAQcJAQEJAQEBAQsBAQgCAwsAAQkACAILAAEJAAEJAAEGCQABCAICCwABCQAIAgELAAEJAAIGCAMFAQYIAwEFAgUJAAIHCAMFAQcJAAQLAAEJAAsAAQkACQEFAgUFAgsAAQkABQELAQEJAAJJRAZPcHRpb24DVUlEB1dyYXBwZXIDYWRkEGFkZF9jaGlsZF9vYmplY3QGYm9ycm93E2JvcnJvd19jaGlsZF9vYmplY3QXYm9ycm93X2NoaWxkX29iamVjdF9tdXQKYm9ycm93X211dA1keW5hbWljX2ZpZWxkFGR5bmFtaWNfb2JqZWN0X2ZpZWxkB2V4aXN0c18QZXhpc3RzX3dpdGhfdHlwZQpmaWVsZF9pbmZvDmZpZWxkX2luZm9fbXV0GGhhc19jaGlsZF9vYmplY3Rfd2l0aF90eQJpZA9pZF9mcm9tX2FkZHJlc3MEbmFtZQRub25lBm9iamVjdAZvcHRpb24GcmVtb3ZlE3JlbW92ZV9jaGlsZF9vYmplY3QEc29tZQ51aWRfdG9fYWRkcmVzcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAgETCQAACgABAAAJFQsBOQAMBQ4COAAMBAoACgULBDgBCwALBQwDLgsDOAIBERULAjgDAgEBAAAOCAsBOQAMAgsACwI4AjgEAgIBAAAOCAsBOQAMAgsACwI4BTgGAgMBAAAVFAsBOQAMAwoACgMMAi4LAjgCDAURFQsFOAcMBAsACwM4CAELBAIEAQAADgcLATkADAILAAsCOAkCBQEAABcUCwE5AAwCCgAKAjgJIAQMCwABCQILAAsCOAIMAxEVCwM4CgIGAQAAFxULATkADAIKAAoCOAkgBAwLAAE4CwILAAsCOAIMAwELAxEUOAwCADYKdHhfY29udGV4dAlUeENvbnRleHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZvYmplY3QCSUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZvYmplY3QDVUlEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA2JhZwNCYWcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdiYWxhbmNlBlN1cHBseQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2JhbGFuY2UHQmFsYW5jZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA2JjcwNCQ1MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZib3Jyb3cIUmVmZXJlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZib3Jyb3cGQm9ycm93AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFY2xvY2sFQ2xvY2sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgN1cmwDVXJsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEY29pbgRDb2luAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEY29pbgxDb2luTWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luC1RyZWFzdXJ5Q2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEY29pbg9DdXJyZW5jeUNyZWF0ZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgd2ZWNfbWFwBlZlY01hcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB3ZlY19tYXAFRW50cnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdwYWNrYWdlCVB1Ymxpc2hlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB3BhY2thZ2UKVXBncmFkZUNhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB3BhY2thZ2UNVXBncmFkZVRpY2tldAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB3BhY2thZ2UOVXBncmFkZVJlY2VpcHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdkaXNwbGF5B0Rpc3BsYXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdkaXNwbGF5DkRpc3BsYXlDcmVhdGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHZGlzcGxheQ5WZXJzaW9uVXBkYXRlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACFGR5bmFtaWNfb2JqZWN0X2ZpZWxkB1dyYXBwZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdncm90aDE2BUN1cnZlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHZ3JvdGgxNhRQcmVwYXJlZFZlcmlmeWluZ0tleQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2dyb3RoMTYRUHVibGljUHJvb2ZJbnB1dHMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdncm90aDE2C1Byb29mUG9pbnRzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHdmVjX3NldAZWZWNTZXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNzdWkDU1VJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5D1RyYW5zZmVyUmVxdWVzdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD3RyYW5zZmVyX3BvbGljeQ5UcmFuc2ZlclBvbGljeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD3RyYW5zZmVyX3BvbGljeRFUcmFuc2ZlclBvbGljeUNhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD3RyYW5zZmVyX3BvbGljeRVUcmFuc2ZlclBvbGljeUNyZWF0ZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg90cmFuc2Zlcl9wb2xpY3kHUnVsZUtleQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBWtpb3NrBUtpb3NrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sNS2lvc2tPd25lckNhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBWtpb3NrC1B1cmNoYXNlQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sESXRlbQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBWtpb3NrB0xpc3RpbmcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawRMb2NrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sKSXRlbUxpc3RlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDGxpbmtlZF90YWJsZQtMaW5rZWRUYWJsZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDGxpbmtlZF90YWJsZQROb2RlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIKb2JqZWN0X2JhZwlPYmplY3RCYWcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgxvYmplY3RfdGFibGULT2JqZWN0VGFibGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg5wcmlvcml0eV9xdWV1ZQ1Qcmlvcml0eVF1ZXVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIOcHJpb3JpdHlfcXVldWUFRW50cnkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgV0YWJsZQVUYWJsZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCXRhYmxlX3ZlYwhUYWJsZVZlYwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCXZlcnNpb25lZAlWZXJzaW9uZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgl2ZXJzaW9uZWQQVmVyc2lvbkNoYW5nZUNhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAAAAAAAAAMAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAQAAAAAAAAALB2dlbmVzaXP2EqEc6wsGAAAACgEAGgIaOgNUawS/AQ4FzQGwAgf9A4kJCIYNYArmDV0Mww7pAw2sEhgAHwEsAUgCEgIUAisCPQJCADYAPwBAAEMARgADAwAAAgMAAAkAAAAIAAABBAcBAAADAAQBAAEEAQwBAAEFCwQABgUCAAcKAgAIBgQACgcEAAsMBAAAFgABAAAPAgEAAA4DAQABGRkaAQABJBgOAQACIxYOAQADGgkBAQADNQgJAQADSwEJAQAEHR4fAQAGQSABAAcbBQYACBYREgAJFhMBAAoXDxAACw0iAQALKgwKAAs0HQEADCAbHAAMIg0OAAcHCAcFFQQXAxcJBwYHBggHCwUBCAgIAQoIAAgCBwgJAAQLBQEICAoIAwcKCAwHCAkBBwoIDBkKCAMDAwoCAwMKAgoCCgIKAgoCCgIKAgoCCgIICgMLBQEICAsFAQgIBQgLCAwKCAwKAgoCAQYICQEDAQgIAgcLBQEJAAMBCwUBCQABCAwBCAAQBQoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgJAgYKCAwGCAwBAQgDAwMDAwMDBwgJAQgLBQsFAQgIAwMNBwgJAQgKCAgHCggMCwUBCAgDAwgLCAoHCAkFCwUBCAgDBQsEAQUFAQgDAQYKCQABBQEGCwQBCQABCwQBCQABCQACBwoIDAUBBwgMBAcIDAsFAQgIBQcICQILBQEJAAcICQELBgEJAAILBgEICAUCAwMCBwgMAwdCYWxhbmNlBENvaW4WR2VuZXNpc0NoYWluUGFyYW1ldGVycxhHZW5lc2lzVmFsaWRhdG9yTWV0YWRhdGEGT3B0aW9uA1NVSQxTdGFrZVN1YnNpZHkQU3lzdGVtUGFyYW1ldGVycw9Ub2tlbkFsbG9jYXRpb24ZVG9rZW5EaXN0cmlidXRpb25TY2hlZHVsZQlUeENvbnRleHQDVUlECVZhbGlkYXRvcghhY3RpdmF0ZRNhY3RpdmF0ZV92YWxpZGF0b3JzD2FsbG9jYXRlX3Rva2VucwthbGxvY2F0aW9ucwthbW91bnRfbWlzdAdiYWxhbmNlGGNoYWluX3N0YXJ0X3RpbWVzdGFtcF9tcwRjb2luD2NvbW1pc3Npb25fcmF0ZQZjcmVhdGUYY3JlYXRlX3N5c3RlbV9wYXJhbWV0ZXJzC2Rlc2NyaXB0aW9uDGRlc3Ryb3lfc29tZQxkZXN0cm95X3plcm8FZXBvY2gRZXBvY2hfZHVyYXRpb25fbXMMZnJvbV9iYWxhbmNlCWdhc19wcmljZQdnZW5lc2lzEWdldF92YWxpZGF0b3JfbXV0CWltYWdlX3VybBZpc19kdXBsaWNhdGVfdmFsaWRhdG9yCGlzX2VtcHR5B2lzX3NvbWUTbWF4X3ZhbGlkYXRvcl9jb3VudBttaW5fdmFsaWRhdG9yX2pvaW5pbmdfc3Rha2UEbmFtZQ9uZXR3b3JrX2FkZHJlc3MSbmV0d29ya19wdWJsaWNfa2V5A25ldwZvYmplY3QGb3B0aW9uC3AycF9hZGRyZXNzD3ByaW1hcnlfYWRkcmVzcwtwcm9qZWN0X3VybBNwcm9vZl9vZl9wb3NzZXNzaW9uE3Byb3RvY29sX3B1YmxpY19rZXkQcHJvdG9jb2xfdmVyc2lvbhFyZWNpcGllbnRfYWRkcmVzcxxyZXF1ZXN0X2FkZF9zdGFrZV9hdF9nZW5lc2lzBXNwbGl0DXN0YWtlX3N1YnNpZHkbc3Rha2Vfc3Vic2lkeV9kZWNyZWFzZV9yYXRlF3N0YWtlX3N1YnNpZHlfZnVuZF9taXN0KXN0YWtlX3N1YnNpZHlfaW5pdGlhbF9kaXN0cmlidXRpb25fYW1vdW50G3N0YWtlX3N1YnNpZHlfcGVyaW9kX2xlbmd0aBlzdGFrZV9zdWJzaWR5X3N0YXJ0X2Vwb2NoFXN0YWtlZF93aXRoX3ZhbGlkYXRvcgNzdWkLc3VpX2FkZHJlc3MKc3VpX3N5c3RlbRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyCHRyYW5zZmVyCnR4X2NvbnRleHQJdmFsaWRhdG9yIHZhbGlkYXRvcl9sb3dfc3Rha2VfZ3JhY2VfcGVyaW9kHXZhbGlkYXRvcl9sb3dfc3Rha2VfdGhyZXNob2xkDXZhbGlkYXRvcl9zZXQidmFsaWRhdG9yX3ZlcnlfbG93X3N0YWtlX3RocmVzaG9sZAZ2ZWN0b3IOd29ya2VyX2FkZHJlc3MRd29ya2VyX3B1YmxpY19rZXkEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgACDycKAhgKAiEKAi8KAj4FHgMVAzEKAjAKAikKAkoKAigKAi0KAi4KAkkKAgECDDIDEwMcAzsDOQM6AzcNJQMmA0UDRwNEAwICAjgDEAoIAwMCAzMFEQM8CwQBBQAAAAAEkwEKBS4RCwYAAAAAAAAAACEEBwULCwUBBgAAAAAAAAAAJwsEEwIMBgwWDQELFjgADBg4AQwXQAoAAAAAAAAAAAwcDgNBCwwIBgAAAAAAAAAADAsKCwoIIwRZBSEOAwoLQgsUEwAMHQwRDBAMDgweDA8MEwwUDAcMCgwZDBIMDAwJDA0LGQsUCw8LHgsTCw0LCQsMCxILDgsQCxELHQsKCwcKBREQDBsOHA4bERMgBE0FUQsFAQYCAAAAAAAAACcNHAsbRAoLCwYBAAAAAAAAABYMCwUcCwELBg0cCgURAQ0cEQIOAhAAFA4CEAEUDgIQAhQOAhADFA4CEAQUDgIQBRQOAhAGFAoFEQ4MGgsYDgIQBxQOAhAIFA4CEAkUCgURDAwVCwALHAsXDgIQChQOAhALFAsaCxULBRENAgEAAAAULA4BOAIgBCMFBQ0BRRUTAwwHDAUMBg0ACwU4AAwEDgc4AwQdCwc4BAwICgILCBESCwQLBgoDEREFIgsECgM4BQsGEQoFAAsCAQsDAQsBRhUAAAAAAAAAAAsAOAYCAgAAACEYCgAuQQoMAQYAAAAAAAAAAAwCCgIKASMEFQULCgAKAkMKBgAAAAAAAAAAEQ8LAgYBAAAAAAAAABYMAgUGCwABAgECAQMBBwEIAQkBCgELAQQBBQEGAQABAQAJdmFsaWRhdG9ynzyhHOsLBgAAAAwBAB8CH0gDZ7cEBJ4FJgXEBe4DB7IJyRMI+xxgBtsdlgEK8R6cAQyNIIwbDZk7PA/VOw0AhgEBFAEXAUkBZwIVAhYCIgJHAmgCbwKDAQBlAIgBAA4EAAANBAAACAMAAAsDAAEJBwADAwcBAAAECQcABQAMAAYBBAEAAQgCBwAJBQIACgoCAAsMBwAMBAcADAYIAAwHDAANDwIAADcAAQAANQIDAAAaBAUAABAEBQAAEgYFAABWBwUAAFcHBQAAWggFAABZCQUAAF4JBQAAWAQFAABdBAUAAB0KBQAAUgsFAAAuDA0AADAMDgAAaQwPAAAxDBAAAB4MEAAAKQwRAABTDBEAADMMEAAASgwQAABPDBAAAI4BDBAAAFUMEgAAVAwSAAA0DBIAAI8BDBIAAD0MEwAAPwwTAABADBMAAEQMEwAAQgwUAABBDBQAAD4MFAAARQwUAABIDBUAADsMFgAAbgwWAABiDBYAAG0MFgAAjQEMFgAAXwQFAABLDBYAAEwMFgAAJgwWAAAZDBYAAE4XGAAAZgwZAAAqGg0AACwbDQEAACscDQEAADkLBQAAeh0FAAB4HQUAAHkdBQAAggEdBQAAex0FAABxHQUAAH0dBQAAcx0FAAB+HQUAAHQdBQAAgAEdBQAAdh0FAAB/HgUAAHUeBQAAfB0FAAByHQUAAIEBHQUAAHcdBQAAHwYFAACEAQ4FAACFAR8FAAA2IAMAAWcfJgACbD4fAQADGEA+AQADJEMzAQADLUANAQADL0ANAQADRgUiAQADYDMiAQAEJSYjAAU1KCkABosBLRYBAAcgMwUBAwgoPhkBCAohLhYAClwuDwALOB8nAAwRKgUADBsqBQAMHDoFAAwuMA0ADDUoPQAMSzAWAAxMMBYADE48GAAMUTEFAAxSOwUADFYvBQAMWjYWAAxhNRYADGM1FgAMajAWAA05QhkADYwBODkAUh9SI1YsVzJXN1g9NCM0HzMjMx9QM04zUyNTH1EjTyNRH08fTQEOBQoCCgIKAgoCCAYIBggMCAwIBggGCAYIBggHAQgAEAUKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIDAwcICwEIAQIHCAEDAAEHCAEEBwgBCwgBCAoFBwgLAwcIAQgOBwgLAwcIAQgQAwIHCAELCAEICgIHCAEHCAsBBggBAQEBBggAAQUBBggGAQYIDAEGCgIBBgsFAQgGAQYLBQEKAgEGCAkBAwIGCAEDAQgNAQgJAgYIAQYIAQIGCwUBCQAGCQACBgsFAQkABgsFAQkAAgcIAQoCAwcIAQoCCgIBCgIECAADAwcICxYFCAYIBggGCAYLBQEKAgsFAQoCCwUBCgILBQEKAgsFAQgGCwUBCAYKAgsFAQgGCwUBCAYIBwoCCgIKAggGCAYIDAgMAQsFAQkAAQgGCAEBAQEBAQEIAAECAQgEAQgMAQcICwEIBwIHCA8DAgMDAQgKAQYLCAEJAAEGCAsFBwgPCwgBCAoFAwcICwEGCA8BBwgPAQgCAQkABAMDAwMBBggOAwcIDwgOBwgLAQgDAQYIEAEGBQIHCA8LCAEICgIHCA8HCAsCBggPAwEIDwEGCQAbAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQYLBQEJAAIBAQIFBwgLAQcLBQEJAAMICQgPBQNCYWcHQmFsYW5jZQJJRAZPcHRpb24VUG9vbFRva2VuRXhjaGFuZ2VSYXRlA1NVSQlTdGFrZWRTdWkLU3Rha2luZ1Bvb2wTU3Rha2luZ1JlcXVlc3RFdmVudAZTdHJpbmcJVHhDb250ZXh0FVVuc3Rha2luZ1JlcXVlc3RFdmVudANVcmwJVmFsaWRhdG9yEVZhbGlkYXRvck1ldGFkYXRhFVZhbGlkYXRvck9wZXJhdGlvbkNhcAhhY3RpdmF0ZRVhY3RpdmF0ZV9zdGFraW5nX3Bvb2waYWRqdXN0X3N0YWtlX2FuZF9nYXNfcHJpY2UGYW1vdW50BWFzY2lpA2JhZwdiYWxhbmNlA2JjcwZib3Jyb3cPY29tbWlzc2lvbl9yYXRlCmRlYWN0aXZhdGUXZGVhY3RpdmF0ZV9zdGFraW5nX3Bvb2wPZGVwb3NpdF9yZXdhcmRzFWRlcG9zaXRfc3Rha2VfcmV3YXJkcwtkZXNjcmlwdGlvbhplZmZlY3R1YXRlX3N0YWdlZF9tZXRhZGF0YQRlbWl0BWVwb2NoBWV2ZW50DGV4dHJhX2ZpZWxkcwdleHRyYWN0CmZyb21fYXNjaWkJZ2FzX3ByaWNlB2dlbmVzaXMCaWQJaW1hZ2VfdXJsDGlzX2R1cGxpY2F0ZQ1pc19lcXVhbF9zb21lF2lzX2VxdWFsX3NvbWVfYW5kX3ZhbHVlB2lzX25vbmUMaXNfcHJlYWN0aXZlB2lzX3NvbWUIbWV0YWRhdGEEbmFtZQtuZXRfYWRkcmVzcw9uZXR3b3JrX2FkZHJlc3MUbmV0d29ya19wdWJrZXlfYnl0ZXMDbmV3EW5ld19mcm9tX21ldGFkYXRhDG5ld19tZXRhZGF0YRVuZXdfdW5zYWZlX2Zyb21fYnl0ZXMzbmV3X3VudmVyaWZpZWRfdmFsaWRhdG9yX29wZXJhdGlvbl9jYXBfYW5kX3RyYW5zZmVyGm5leHRfZXBvY2hfY29tbWlzc2lvbl9yYXRlFG5leHRfZXBvY2hfZ2FzX3ByaWNlFm5leHRfZXBvY2hfbmV0X2FkZHJlc3MabmV4dF9lcG9jaF9uZXR3b3JrX2FkZHJlc3MfbmV4dF9lcG9jaF9uZXR3b3JrX3B1YmtleV9ieXRlcxZuZXh0X2Vwb2NoX3AycF9hZGRyZXNzGm5leHRfZXBvY2hfcHJpbWFyeV9hZGRyZXNzHm5leHRfZXBvY2hfcHJvb2Zfb2ZfcG9zc2Vzc2lvbiBuZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleV9ieXRlcxBuZXh0X2Vwb2NoX3N0YWtlGW5leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MebmV4dF9lcG9jaF93b3JrZXJfcHVia2V5X2J5dGVzBG5vbmUGb2JqZWN0EG9wZXJhdGlvbl9jYXBfaWQGb3B0aW9uC3AycF9hZGRyZXNzFHBlbmRpbmdfc3Rha2VfYW1vdW50HXBlbmRpbmdfc3Rha2Vfd2l0aGRyYXdfYW1vdW50B3Bvb2xfaWQhcG9vbF90b2tlbl9leGNoYW5nZV9yYXRlX2F0X2Vwb2NoD3ByaW1hcnlfYWRkcmVzcxBwcmluY2lwYWxfYW1vdW50FXByb2Nlc3NfcGVuZGluZ19zdGFrZSRwcm9jZXNzX3BlbmRpbmdfc3Rha2VzX2FuZF93aXRoZHJhd3MLcHJvamVjdF91cmwTcHJvb2Zfb2ZfcG9zc2Vzc2lvbhVwcm90b2NvbF9wdWJrZXlfYnl0ZXMRcmVxdWVzdF9hZGRfc3Rha2UccmVxdWVzdF9hZGRfc3Rha2VfYXRfZ2VuZXNpcxtyZXF1ZXN0X3NldF9jb21taXNzaW9uX3JhdGUVcmVxdWVzdF9zZXRfZ2FzX3ByaWNlFnJlcXVlc3Rfd2l0aGRyYXdfc3Rha2UNcmV3YXJkX2Ftb3VudAZzZW5kZXIdc2V0X2NhbmRpZGF0ZV9jb21taXNzaW9uX3JhdGUXc2V0X2NhbmRpZGF0ZV9nYXNfcHJpY2UQc2V0X3ZvdGluZ19wb3dlcgRzb21lFnN0YWtlX2FjdGl2YXRpb25fZXBvY2gMc3Rha2VfYW1vdW50EXN0YWtlZF9zdWlfYW1vdW50DnN0YWtlcl9hZGRyZXNzDHN0YWtpbmdfcG9vbA9zdGFraW5nX3Bvb2xfaWQGc3RyaW5nA3N1aQtzdWlfYWRkcmVzcwtzdWlfYmFsYW5jZRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyCHRvX2J5dGVzC3RvdGFsX3N0YWtlEnRvdGFsX3N0YWtlX2Ftb3VudAp0eF9jb250ZXh0D3Vuc3Rha2luZ19lcG9jaCB1cGRhdGVfY2FuZGlkYXRlX25ldHdvcmtfYWRkcmVzcx91cGRhdGVfY2FuZGlkYXRlX25ldHdvcmtfcHVia2V5HHVwZGF0ZV9jYW5kaWRhdGVfcDJwX2FkZHJlc3MgdXBkYXRlX2NhbmRpZGF0ZV9wcmltYXJ5X2FkZHJlc3MgdXBkYXRlX2NhbmRpZGF0ZV9wcm90b2NvbF9wdWJrZXkfdXBkYXRlX2NhbmRpZGF0ZV93b3JrZXJfYWRkcmVzcx51cGRhdGVfY2FuZGlkYXRlX3dvcmtlcl9wdWJrZXkSdXBkYXRlX2Rlc2NyaXB0aW9uEHVwZGF0ZV9pbWFnZV91cmwLdXBkYXRlX25hbWUhdXBkYXRlX25leHRfZXBvY2hfbmV0d29ya19hZGRyZXNzIHVwZGF0ZV9uZXh0X2Vwb2NoX25ldHdvcmtfcHVia2V5HXVwZGF0ZV9uZXh0X2Vwb2NoX3AycF9hZGRyZXNzIXVwZGF0ZV9uZXh0X2Vwb2NoX3ByaW1hcnlfYWRkcmVzcyF1cGRhdGVfbmV4dF9lcG9jaF9wcm90b2NvbF9wdWJrZXkgdXBkYXRlX25leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MfdXBkYXRlX25leHRfZXBvY2hfd29ya2VyX3B1YmtleRJ1cGRhdGVfcHJvamVjdF91cmwDdXJsEXZhbGlkYXRlX21ldGFkYXRhFXZhbGlkYXRlX21ldGFkYXRhX2Jjcwl2YWxpZGF0b3IRdmFsaWRhdG9yX2FkZHJlc3MNdmFsaWRhdG9yX2NhcA12YWxpZGF0b3Jfc2V0EXZhbGlkYXRvcl93cmFwcGVyBXZhbHVlHnZlcmlmaWVkX29wZXJhdGlvbl9jYXBfYWRkcmVzcwx2b3RpbmdfcG93ZXIOd29ya2VyX2FkZHJlc3MTd29ya2VyX3B1YmtleV9ieXRlcwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAMIBgAAAAAAAAADCAcAAAAAAAAAAwgIAAAAAAAAAAMICQAAAAAAAAADCAoAAAAAAAAAAwhkAAAAAAAAAAMIZQAAAAAAAAADCBAnAAAAAAAAAwgAAQAAAAAAAAACFmkFVQoCNAoCjwEKAlQKAjEIBh4IBikIDFMIDDIIBkoIBk8IBo4BCAZCCwUBCgJBCwUBCgI+CwUBCgJFCwUBCgI8CwUBCAY/CwUBCAZACwUBCAZECwUBCAYjCAcBAgowCACNAQNICAkmA2UIDxkDQwM7AzoDIwgHAgIFTQgJhwEFZAUhAxMDAwIHTQgJhwEFZAVhA3ADUANbAwADAAAhRAsADA4LAQwZCwIMHQsDDB4LBAwfCwUMIAsGDCELBwwiCwgMIwsJDA8LCgwQCwsMEQsMDBI4AAwTOAAMFDgADBU4AAwWOAEMFzgBDBg4AQwaOAEMGwsNDBwLDgsZCx0LHgsfCyALIQsiCyMLDwsQCxELEgsTCxYLFAsVCxcLGAsaCxsLHBIAAgEDAAAkgAEOCUElBw4lBAsOCkElBw4lDBAFDQkMEAsQBBUOC0ElBw4lDBEFFwkMEQsRBB8ODEElBw4lDBIFIQkMEgsSBCkOBUElBw4lDBMFKwkMEwsTBDMOBkElBw4lDBQFNQkMFAsUBD0OB0ElBw4lDBUFPwkMFQsVBEcOCEElBw4lDBYFSQkMFgsWBEwFUAsPAQcJJwoOBw0lBFUFWQsPAQcIJwsACwELAgsDCwQLBRFMEVQLBhFMEVQLBxFbCwgRWwsJEUwRVAsKEUwRVAsLEUwRVAsMEUwRVAoPEVURAAwXDhcRSQsXCw0LDgsPEUsCAgMAAAUFCwAPAAsBEV0CAwMAAAUFCwAPAAsBEVwCBAMAAAUNCgAQARQKAA8CFQoAEAMUCwAPBBUCBQMAACs5DgE4AgwECgQGAAAAAAAAAAAkBAgFDgsAAQsDAQYAAAAAAAAAACcKAy4RWQYBAAAAAAAAABYMBQoADwALAQoCCwUKAxFmCgAQABFfBCIKAA8AEWQKABAFFAoEFgoADwUVCgAuETELABAGEAcUCwILAy4RWQsEEgI4AwIGAwAAFi4KAy4RWQYAAAAAAAAAACEEBwUNCwABCwMBBgAAAAAAAAAAJw4BOAIMBAoEBgAAAAAAAAAAJAQVBRsLAAELAwEGAAAAAAAAAAAnCgAPAAsBCwIGAAAAAAAAAAALAxFmCgAPABFkCgAQBRQLBBYLAA8FFQIHAwAANCsOARFpDAMOARFoDAUKAA8ACwEKAhFnDAYKBgoDFwwECgAQBRQLBhcKAA8FFQoALhExCwAQBhAHFAoCLhFaCwULAi4RWQsDCwQSAzgEAggDAAAFEw4BEWwUCgAQBhAHFCEECgUOCwABBwwnCwILAA8BFQIJAwAABSAKAC4RDgQFBQkLAAEHCicOARFsFAoAEAYQBxQhBBMFFwsAAQcMJwoCCgAPARULAgsADwIVAgoDAAAFDgoBBw0lBAUFCQsAAQcIJwsBCwAPAxUCCwMAAAUXCgAuEQ4EBQUJCwABBwonCgEHDSUEDgUSCwABBwgnCwELAA8EFQIMAwAABQ4KABAFFA4BOAIWCgAPBRULAA8ACwERXgINAwAABRAKAA8ACwERZQoALhEoCwAQBRQhBA0FDwYAAAAAAAAAACcCDgEAAAUECwAQABFfAg8BAAAFAwsAEAYCEAEAAAUFCwAQBhAHFAIRAQAABQQLABAGEAgCEgEAAAUECwAQBhAJAhMBAAAFBAsAEAYQCgIUAQAABQQLABAGEAsCFQEAAAUECwAQBhAMAhYBAAAFBAsAEAYQDQIXAQAABQQLABAGEA4CGAEAAAUECwAQBhAPAhkBAAAFBAsAEAYQEAIaAQAABQQLABAGEBECGwEAAAUECwAQBhASAhwBAAAFBAsAEAYQEwIdAQAABQQLABAGEBQCHgEAAAUECwAQBhAVAh8BAAAFBAsAEAYQFgIgAQAABQQLABAGEBcCIQEAAAUECwAQBhAYAiIBAAAFBAsAEAYQGQIjAQAABQQLABAGEBoCJAEAAAUECwAQBhAbAiUBAAAFAwsAEBwCJgEAAAUECwAQARQCJwEAAAUFKAsAEAARagIoAQAABQQLABAAEWoCKQEAAAUDCwARKAIqAQAABQQLABAdFAIrAwAABQULAQsADx0VAiwBAAAFBAsAEAARYQItAQAABQQLABAAEWICLgEAAAUECwAQAhQCLwEAAAUECwAQBBQCMAEAAAUFCwAQAAsBEWMCMQEAAAUECwAQADgFAjIBAAA/+QIKABAGEAcUCgEQBhAHFCEEDQgMAgUXCgAQBhAIFAoBEAYQCBQhDAILAgQcCAwNBSYKABAGEBAUCgEQBhAQFCEMDQsNBCsIDBYFNQoAEAYQEhQKARAGEBIUIQwWCxYEOggMFwVECgAQBhASFAoBEAYQExQhDBcLFwRJCAwYBVMKABAGEBMUCgEQBhATFCEMGAsYBFgIDBkFYgoAEAYQExQKARAGEBIUIQwZCxkEZwgMGgVvCgAQBhAUCgEQBhAUOAYMGgsaBHQIDBsFfAoAEAYQFQoBEAYQFTgGDBsLGwSBAQgMHAWJAQoAEAYQGAoBEAYQGDgHDBwLHASOAQgMAwWWAQoAEAYQGgoBEAYQGjgHDAMLAwSbAQgMBAWjAQoAEAYQGgoBEAYQGzgHDAQLBASoAQgMBQWwAQoAEAYQGwoBEAYQGzgHDAULBQS1AQgMBgW9AQoAEAYQGwoBEAYQGjgHDAYLBgTCAQgMBwXKAQoAEAYQFAoBEAYQDDgIDAcLBwTPAQgMCAXXAQoAEAYQFQoBEAYQDTgIDAgLCATcAQgMCQXkAQoAEAYQGAoBEAYQEDgJDAkLCQTpAQgMCgXxAQoAEAYQGgoBEAYQEjgJDAoLCgT2AQgMCwX+AQoAEAYQGgoBEAYQEzgJDAsLCwSDAggMDAWLAgoAEAYQGwoBEAYQEzgJDAwLDASQAggMDgWYAgoAEAYQGwoBEAYQEjgJDA4LDgSdAggMDwWlAgoBEAYQFAoAEAYQDDgIDA8LDwSqAggMEAWyAgoBEAYQFQoAEAYQDTgIDBALEAS3AggMEQW/AgoBEAYQGAoAEAYQEDgJDBELEQTEAggMEgXMAgoBEAYQGgoAEAYQEjgJDBILEgTRAggMEwXZAgoBEAYQGgoAEAYQEzgJDBMLEwTeAggMFAXmAgoBEAYQGwoAEAYQEzgJDBQLFATvAgsAAQsBAQgMFQX3AgsBEAYQGwsAEAYQEjgJDBULFQIzAAAADREKADgKBAoLAQELAAEJDAIFDwsAOAsLASEMAgsCAjQAAABBGgoAOAoEBggMAgUJCgE4CgwCCwIEEgsBAQsAAQkMAwUYCwA4CwsBOAshDAMLAwI1AwAADxkKAS4RWgwCCgIKABAGEAcUIQQMBRILAAELAQEHCycLAgsBEWsLAA8cFQI2AwAABRIOAUElBw4lBAYFCgsAAQcJJwsBEUwRVAsADwYPCBUCNwMAAAUSDgFBJQcOJQQGBQoLAAEHCScLARFMEVQLAA8GDwkVAjgDAAAFEQ4BQSUHDiUEBgUKCwABBwknCwERWwsADwYPChUCOQMAAAURDgFBJQcOJQQGBQoLAAEHCScLARFbCwAPBg8LFQI6AwAABRYOAUElBw4lBAYFCgsAAQcJJwsBEUwRVDgMCgAPBg8UFQsAEAYRSQI7AwAABR4KAC4RDgQFBQkLAAEHCicOAUElBw4lBA8FEwsAAQcJJwsBEUwRVAoADwYPDBULABAGEUkCPAMAAAUWDgFBJQcOJQQGBQoLAAEHCScLARFMEVQ4DAoADwYPFRULABAGEUkCPQMAAAUeCgAuEQ4EBQUJCwABBwonDgFBJQcOJQQPBRMLAAEHCScLARFMEVQKAA8GDw0VCwAQBhFJAj4DAAAFFg4BQSUHDiUEBgUKCwABBwknCwERTBFUOAwKAA8GDxYVCwAQBhFJAj8DAAAFHgoALhEOBAUFCQsAAQcKJw4BQSUHDiUEDwUTCwABBwknCwERTBFUCgAPBg8OFQsAEAYRSQJAAwAABRYOAUElBw4lBAYFCgsAAQcJJwsBEUwRVDgMCgAPBg8XFQsAEAYRSQJBAwAABR4KAC4RDgQFBQkLAAEHCicOAUElBw4lBA8FEwsAAQcJJwsBEUwRVAoADwYPDxULABAGEUkCQgMAAAUQCwE4DQoADwYPGBULAjgNCgAPBg8ZFQsAEAYRSQJDAwAABRcKAC4RDgQFBQkLAAEHCicLAQoADwYPEBULAgoADwYPERULABAGEUkCRAMAAAUKCwE4DQoADwYPGhULABAGEUkCRQMAAAUSCgAuEQ4EBQUJCwABBwonCwEKAA8GDxIVCwAQBhFJAkYDAAAFCgsBOA0KAA8GDxsVCwAQBhFJAkcDAAAFEgoALhEOBAUFCQsAAQcKJwsBCgAPBg8TFQsAEAYRSQJIAwAABY8BCgAuER04DgQSCgAPBg8UOA8KAA8GDwwVOAEKAA8GDxQVCgAuER44DgQkCgAPBg8VOA8KAA8GDw0VOAEKAA8GDxUVCgAuER84DgQ2CgAPBg8WOA8KAA8GDw4VOAEKAA8GDxYVCgAuESA4DgRICgAPBg8XOA8KAA8GDw8VOAEKAA8GDxcVCgAuESE4EARnCgAPBg8YOBEKAA8GDxAVOAAKAA8GDxgVCgAPBg8ZOBEKAA8GDxEVOAAKAA8GDxkVCgAuESM4EAR5CgAPBg8aOBEKAA8GDxIVOAAKAA8GDxoVCgAuESQ4EASMAQoADwYPGzgRCgAPBg8TFTgACwAPBg8bFQWOAQsAAQJJAQAABQQLADgSEUoCSgECAEsAAABEGA4AEAcUDAYKAxFgDAULBgoDEWsMBAsABgAAAAAAAAAACwQKAQsFCgIGAAAAAAAAAAALAQsCCwMRVRIBAgEEAQcBAwEIAQUBBgEAAAAABQAGAAcACAAJAAoACwAMAAEABAACAAMAEQASABMAFAANAA4ADwAQAQIBAQAnAGsAiQEAigEAjQEACnN1aV9zeXN0ZW3aG6Ec6wsGAAAADAEAHAIcOgNWkAME5gMGBewDvQMHqQexDAjaE2AGuhQiCtwUCAzkFLUGDZkbBA+dGwIALwEcAhACEgIUAhsCLgIyAjMALAAtADAARwBIAAYIAAECBwEAAAIABAEAAQMBDAEAAQUKBAAGAwIACAkCAAkEBAAKBQgACwcEAAsIBAAMDAQADQsMAAATAAEAACECAQAAIwMBAAAgAwEAACIDAQAAJQQBAAAqBAEAACQFAQAAKQUBAAAeBgEAAB8HAQAAJggBAAAdCQEAADQJAQAAJwMBAAA+CgEAADwKAQAAPQoBAABGCgEAAD8KAQAANQoBAABBCgEAADcKAQAAQgoBAAA4CgEAAEQKAQAAOgoBAABDCwEAADkLAQAARQoBAAA7CgEAAEAKAQAANgoBAAAODA0AAA8OAQAAGQ8QAAAaDxEAABgPEQAEDRcBAgcEBBEpKgIHBAcrGQEBCAgoJCUACw4mDQALDycBAAsTExQACxYBFQALHSEBAAseHgEACx8fAQALIBsBAAshGgEACyIbAQALIxsBAAskHQEACyUcAQALJiABAAsnGwEACykdAQALKhwBAAsxEBUACzQhAQALNSIBAAs2IgEACzciAQALOCIBAAs5IwEACzoiAQALOyIBAAs8IgEACz0iAQALPiIBAAs/IgEAC0AiAQALQSIBAAtCIgEAC0MjAQALRCIBAAtFIgEAC0YiAQAmFigYJxYICAQKCAsLAgEIBQMDCAoIBwcIBgAQBwgACgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCAwMHCAYCBwgABwgGAwcIAAYIDAMDBwgAAwcIBgQHCAALAwEIBQUHCAYFBwgACgsDAQgFCwEBAwUHCAYDBwgACAgHCAYDBwgABggMBQMHCAAKAgYIBgQHCAAKAgoCBggGCwsCAQgFCwIBCAUHCAADAwMDAwMDBwgGAQsCAQgFCAsCAQgFCwIBCAUHCAADAwMDBwgGAQcIAAEGCAkBBwgJAwgACAkDBwoICwsCAQgFAwMICggHBwgGAQgJAQMCAwgJAwcIBAkACQEBCAABCQAQBwgJCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCAwMHCAYCBwgJBwgGAwcICQYIDAMDBwgJAwcIBgQHCAkLAwEIBQUHCAYFBwgJCgsDAQgFCwEBAwUHCAYDBwgJCAgHCAYDBwgJBggMBQMHCAkKAgYIBgQHCAkKAgoCBggGAQYIBgEFCwcICQMDCwIBCAULAgEIBQMDAwMDBwgGCAcICQMDCwIBCAULAgEIBQMDBwgGAgcICQMCBwgECQABBwkBB0JhbGFuY2UEQ29pbgZPcHRpb24DU1VJDFN0YWtlU3Vic2lkeQlTdGFrZWRTdWkOU3VpU3lzdGVtU3RhdGUTU3VpU3lzdGVtU3RhdGVJbm5lchBTeXN0ZW1QYXJhbWV0ZXJzCVR4Q29udGV4dANVSUQfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAlWYWxpZGF0b3IDYWRkDWFkdmFuY2VfZXBvY2gXYWR2YW5jZV9lcG9jaF9zYWZlX21vZGUHYmFsYW5jZQpib3Jyb3dfbXV0BGNvaW4GY3JlYXRlDWR5bmFtaWNfZmllbGQHZ2VuZXNpcxxnZW5lc2lzX3N5c3RlbV9zdGF0ZV92ZXJzaW9uAmlkGGxvYWRfaW5uZXJfbWF5YmVfdXBncmFkZRFsb2FkX3N5c3RlbV9zdGF0ZRVsb2FkX3N5c3RlbV9zdGF0ZV9tdXQGb2JqZWN0Bm9wdGlvbhByZXBvcnRfdmFsaWRhdG9yEXJlcXVlc3RfYWRkX3N0YWtlGnJlcXVlc3RfYWRkX3N0YWtlX211bF9jb2luFXJlcXVlc3RfYWRkX3ZhbGlkYXRvch9yZXF1ZXN0X2FkZF92YWxpZGF0b3JfY2FuZGlkYXRlGHJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvciJyZXF1ZXN0X3JlbW92ZV92YWxpZGF0b3JfY2FuZGlkYXRlG3JlcXVlc3Rfc2V0X2NvbW1pc3Npb25fcmF0ZRVyZXF1ZXN0X3NldF9nYXNfcHJpY2UWcmVxdWVzdF93aXRoZHJhd19zdGFrZRRyb3RhdGVfb3BlcmF0aW9uX2NhcAZzZW5kZXInc2V0X2NhbmRpZGF0ZV92YWxpZGF0b3JfY29tbWlzc2lvbl9yYXRlIXNldF9jYW5kaWRhdGVfdmFsaWRhdG9yX2dhc19wcmljZQxzaGFyZV9vYmplY3QNc3Rha2Vfc3Vic2lkeQxzdGFraW5nX3Bvb2wDc3VpCnN1aV9zeXN0ZW0Wc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchRzeXN0ZW1fc3RhdGVfdmVyc2lvbgh0cmFuc2Zlcgp0eF9jb250ZXh0FXVuZG9fcmVwb3J0X3ZhbGlkYXRvcip1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9uZXR3b3JrX2FkZHJlc3MpdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfbmV0d29ya19wdWJrZXkmdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcDJwX2FkZHJlc3MqdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcHJpbWFyeV9hZGRyZXNzKnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3Byb3RvY29sX3B1YmtleSl1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl93b3JrZXJfYWRkcmVzcyh1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl93b3JrZXJfcHVia2V5HHVwZGF0ZV92YWxpZGF0b3JfZGVzY3JpcHRpb24adXBkYXRlX3ZhbGlkYXRvcl9pbWFnZV91cmwVdXBkYXRlX3ZhbGlkYXRvcl9uYW1lK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9uZXR3b3JrX2FkZHJlc3MqdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX25ldHdvcmtfcHVia2V5J3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wMnBfYWRkcmVzcyt1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfcHJpbWFyeV9hZGRyZXNzK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wcm90b2NvbF9wdWJrZXkqdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3dvcmtlcl9hZGRyZXNzKXVwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF93b3JrZXJfcHVia2V5HHVwZGF0ZV92YWxpZGF0b3JfcHJvamVjdF91cmwJdmFsaWRhdG9yDXZhbGlkYXRvcl9jYXAHdmVyc2lvbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIXCARJAwADAAASFwsBCwILAwsECwULBgsHESwMCREtDAoLAAoKEgAMCA0IDwALCgsJOAALCDgBAgEBBAABEwsAESQLAQsCCwMLBAsFCwYLBwsICwkLCgsLCwwLDQsOCw8RMgICAQQAAQULABEkCwERNAIDAQQAAQULABEkCwERMQIEAQQAAQULABEkCwERMwIFAQQAAQYLABEkCwELAhE2AgYBBAABBgsAESQLAQsCEToCBwEEAAEGCwARJAsBCwIRNQIIAQQAAQYLABEkCwELAhE5AgkBBAABBwsAESQLAQsCCwMRLwIKAQQAAQgLABEkCwELAgsDCwQRMAILAQQAAQYLABEkCwELAhE3AgwBBAABBgsAESQLAQsCES4CDQEEAAEGCwARJAsBCwIRPAIOAQQAAQULABEkCwEROAIPAQQAAQYLABEkCwELAhFGAhABBAABBgsAESQLAQsCEUQCEQEEAAEGCwARJAsBCwIRRQISAQQAAQYLABEkCwELAhFOAhMBBAABBgsAESQLAQsCEUcCFAEEAAEGCwARJAsBCwIRPQIVAQQAAQYLABEkCwELAhFJAhYBBAABBgsAESQLAQsCET8CFwEEAAEGCwARJAsBCwIRSgIYAQQAAQYLABEkCwELAhFAAhkBBAABBgsAESQLAQsCEUwCGgEEAAEGCwARJAsBCwIRQgIbAQQAAQcLABEkCwELAgsDEUsCHAEEAAEHCwARJAsBCwILAxFBAh0BBAABBgsAESQLAQsCEU0CHgEEAAEGCwARJAsBCwIRQwIfAQQAAQYLABEkCwELAhFIAiABBAABBgsAESQLAQsCET4CIQAAABEdCwIRJAwLCgouESkHACEECgUQCwsBCwoBBgAAAAAAAAAAJwsLCwMLBAsACwELBQsGCwcLCAsJCwoRKgIiAAAAERoLAhEkDAgKBy4RKQcAIQQKBRALCAELBwEGAAAAAAAAAAAnCwgLAwsECwALAQsFCwYLBxErAiMAAAABBAsAESUuAiQAAAABAwsAESUCJQAAACgWCgAQARQMAgsADwAKAjgCDAEKAS4ROwsCIQQQBRQLAQEGAAAAAAAAAAAnCwECAAAAAQAVAAxzdGFraW5nX3Bvb2zzHaEc6wsGAAAADAEAFgIWOgNQrwIE/wImBaUD4AIHhQaQCQiVD2AG9Q+0AQqpEUIM6xGsCw2XHRwPsx0EAEkBMAIPAhACEwIrAi8CSgJNAk4CTwAIDAAABQcAAAcIAAEEBwEAAAIADAADAQQBAAEEAgwBAAEGAwcABgsEAAcGAgAICQwCBwEEAQoKAgAALQABAAA/AgMAAEAEBQAAVAYHAABQCAkAABgKAwAAPQsDAAA8DAMAADsMAwAAVQ0JAAAMDgMAAEEEBQAAFQ4DAABMDwUAADYQEQAASBAFAABHEAUAACYPEgAAJA8SAABFEwgAAEYTAwAAKhQDAAAjFRIAADkWFwAAMw8FAAA0DwUAACcWEgAAHhgFAAAfGAUAACIDFwAAEhYDAAERNCMBAAEcMQMBAAEgNjMBAwElNBIBAAEoNBIBAAEuAx0BAAFEMx0BAAItACAAAykoBQEAA0UwHwEAA1MiBQEAA1YDHwEABB0pKgEABSwtBQAGFxwDAAYhIxEBCAYtABwACA4uAwIHBAgRNzgCBwQIFDcSAgcECC0AGwIHBAk+JAMBDAlOJAMBCAoZJgUACkMmJwAzGiQFKh4pHi4BNQgnHiseNCswGigeIAUlBSIFIwUhBR8FMhoxGgEHCAsBCAAFBwgACwUBCAkFAwcICwADBwgACAIHCAsBAwIHCAAIAgIDCwUBCAkBCAIBCwUBCAkCBwgACwUBCAkCBwgABwgLAQcIAAQHCAADAwMCBwgAAwEGCAABBggCAQgHAQEDBwgCAwcICwIHCAIIAgIGCAIGCAICBggAAwEIAQIGCAEDAQsKAgMIAQIDCAEBCwoCCQAJAQEICAELAwEJAAEICQELBQEJAAEIBAIIAgMBBgsFAQkAAQYJAAIJAAUGAwsFAQgJAwsFAQgJBQMBBggLAQUCBwsFAQkACwUBCQACCwUBCQAHCAsBCwYBCQABCwYBCAkDAwgBCwUBCAkCAwMDBwsKAgkACQEJAAkBBQMDCAEDAwIHCwUBCQADAgcLAwEJAAkAAwsFAQgJBQMBCQABBgsDAQkAAgYIAgsFAQgJAgYLAwEJAAkAAgYLCgIJAAkBCQABBgkBAwMIAQMDQmFnB0JhbGFuY2UEQ29pbgJJRAZPcHRpb24VUG9vbFRva2VuRXhjaGFuZ2VSYXRlA1NVSQlTdGFrZWRTdWkLU3Rha2luZ1Bvb2wFVGFibGUJVHhDb250ZXh0A1VJRBVhY3RpdmF0ZV9zdGFraW5nX3Bvb2wQYWN0aXZhdGlvbl9lcG9jaANhZGQDYmFnB2JhbGFuY2UGYm9ycm93GGNoZWNrX2JhbGFuY2VfaW52YXJpYW50cwRjb2luCGNvbnRhaW5zF2RlYWN0aXZhdGVfc3Rha2luZ19wb29sEmRlYWN0aXZhdGlvbl9lcG9jaAZkZWxldGUPZGVwb3NpdF9yZXdhcmRzBWVwb2NoDmV4Y2hhbmdlX3JhdGVzDGV4dHJhX2ZpZWxkcwRmaWxsDGZyb21fYmFsYW5jZQ5nZXRfc3VpX2Ftb3VudBBnZXRfdG9rZW5fYW1vdW50EGdldF93aXRoX2RlZmF1bHQCaWQVaW5pdGlhbF9leGNoYW5nZV9yYXRlGWlzX2VxdWFsX3N0YWtpbmdfbWV0YWRhdGELaXNfaW5hY3RpdmUHaXNfbm9uZQxpc19wcmVhY3RpdmUVaXNfcHJlYWN0aXZlX2F0X2Vwb2NoB2lzX3NvbWUEam9pbg9qb2luX3N0YWtlZF9zdWkEbWF0aANtaW4DbmV3BG5vbmUGb2JqZWN0Bm9wdGlvbhtwZW5kaW5nX3Bvb2xfdG9rZW5fd2l0aGRyYXcNcGVuZGluZ19zdGFrZRRwZW5kaW5nX3N0YWtlX2Ftb3VudB1wZW5kaW5nX3N0YWtlX3dpdGhkcmF3X2Ftb3VudBpwZW5kaW5nX3RvdGFsX3N1aV93aXRoZHJhdwdwb29sX2lkEXBvb2xfdG9rZW5fYW1vdW50EnBvb2xfdG9rZW5fYmFsYW5jZSFwb29sX3Rva2VuX2V4Y2hhbmdlX3JhdGVfYXRfZXBvY2gJcHJpbmNpcGFsFXByb2Nlc3NfcGVuZGluZ19zdGFrZR5wcm9jZXNzX3BlbmRpbmdfc3Rha2Vfd2l0aGRyYXckcHJvY2Vzc19wZW5kaW5nX3N0YWtlc19hbmRfd2l0aGRyYXdzD3B1YmxpY190cmFuc2ZlchFyZXF1ZXN0X2FkZF9zdGFrZRZyZXF1ZXN0X3dpdGhkcmF3X3N0YWtlIHJlcXVlc3Rfd2l0aGRyYXdfc3Rha2VfcHJlYWN0aXZlDHJld2FyZHNfcG9vbAZzZW5kZXIEc29tZQVzcGxpdBBzcGxpdF9zdGFrZWRfc3VpFnN0YWtlX2FjdGl2YXRpb25fZXBvY2gRc3Rha2VkX3N1aV9hbW91bnQMc3Rha2luZ19wb29sA3N1aQpzdWlfYW1vdW50C3N1aV9iYWxhbmNlBXRhYmxlCHRyYW5zZmVyCnR4X2NvbnRleHQRdW53cmFwX3N0YWtlZF9zdWkJdmFsaWRhdG9yDXZhbGlkYXRvcl9zZXQFdmFsdWUXd2l0aGRyYXdfZnJvbV9wcmluY2lwYWwQd2l0aGRyYXdfcmV3YXJkcwR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMICgAAAAAAAAADCAsAAAAAAAAAAwgMAAAAAAAAAAMIDQAAAAAAAAADCA4AAAAAAAAAAwgPAAAAAAAAAAMIEAAAAAAAAAADCBEAAAAAAAAAAAILIQgIDQsDAQMWCwMBA0wDQgsFAQgJOAMaCwoCAwgBMgM1AzEDGwgEAQICSwM3AwICBCEICDYIB0cDOgsFAQgJAAMAABkSCgA4AAwBCgARLzgBOAEGAAAAAAAAAAA4AgYAAAAAAAAAAAsBBgAAAAAAAAAABgAAAAAAAAAABgAAAAAAAAAACwARJhIAAgEDAAAhLw4BOAMMBgoALhESIAQJBQ8LAAELBAEHCicKBgYAAAAAAAAAACQEFAUaCwABCwQBBxEnCwQRLwoALjgECwMLARICDAUKABAAFAsGFgsADwAVCwULAjgFAgIDAAAlPQoACwERAwwEDAMKAi4RNwwHDgQ4AwwFCgAKBQoDCgIuETYRCQwGCwUOBjgDFgwICgAQARQKCBYKAA8BFQoAEAIUCwMWCgAPAhUKAC4REgQwCwARBwUyCwABDQQLBjgGAQsECwI4BwsHOAgLCAIDAwAALB8OARADFAoALjgEIQQJBQ0LAAEHAScLAA4BEAQUDAIuCwIRFwwDCwERBAwEDgMOBDgDERwLBAIEAAAACQgLABMCDAEBAREtCwECBQMAAAMPCgAQBRQOATgDFgoADwUVCwAPBgsBOAYBAgYDAAAtHAsBLhE2BgEAAAAAAAAAFgwDCgARBwoAEQgKAA8HCgMKABAFFAoAEAgUEgE4CQsACwMMAi4LAhEeAgcAAAADHQoAEAUUCgAQARQXCgAPBRUKABAIFAoAEAIUFwoADwgVBgAAAAAAAAAACgAPARUGAAAAAAAAAAALAA8CFQIIAwAAFx8KABAFFAoAEAgUEgEMAQoAEAUUCgAQABQWCgAPBRUOAQoAEAUUERwKAA8IFQYAAAAAAAAAAAsADwAVAgkAAAAvIQoACwMMBC4LBBEXDAYOBgsCERsMCAoICgEmBBQLCAsBFwwFBRYGAAAAAAAAAAAMBQsFCgAQBjgDESwMBwsADwYLBzgKAgoDAAADHQoADwcKAREdOAkKAC4REQQKBQ4LAAEHDicKAC4REiAEFAUYCwABBxAnCwAPCQsBOAsCCwMAADI7DgEQAxQKAC44BCEECQUPCwABCwIBBwEnCgAuEREEFAUaCwABCwIBBw8nCgIuETcMBAsBEQQMAw4DOAMMBQoAEAUUCgUXCgAPBRUKABAIFAoFFwsADwgVCwMLAjgHCwQ4CAsFAgwDAAADEAoALhESIAQGBQoLAAEHCycLATgMCwAPChUCDQEAAAMECwAQBRQCDgEAAAMECwAQAxQCDwEAAAMECwAQCzgDAhABAAADBAsAEAQUAhEBAAADBAsAEAk4DQISAQAAAwQLABAKOA4CEwEAAAMOCwIRLwoAEAMUCgAQBBQLAA8LCwE4ChICAhQBBAADCQsACwEKAhETCwIuETc4BQIVAQQANRgKAA4BDAIuCwIRFgQIBQwLAAEHDCcLARMCDAMBAREtCwAPCwsDOAYBAhYBAAASGQoAEAMUCgEQAxQhBBELABAEFAsBEAQUIQwCBRcLAAELAQEJDAILAgIXAQAALS0KAAoBERoECAsAAREdAgoAEAoKATgPCwERLAwDCgAQCTgQFAwCCgMKAiYEKQUZCgAQBwoDOBEEJAsAEAcLAzgSFAILAwYBAAAAAAAAABcMAwUUCwABER0CGAEAAAMECwAQABQCGQEAAAMECwAQARQCGgAAABIRCgAREQQICwABCAwCBQ8LABAJOBAUCwEkDAILAgIbAAAAEiMKABAMFAYAAAAAAAAAACEECQgMAgUPCgAQDRQGAAAAAAAAAAAhDAILAgQVCwABCwECCgAQDBQ1CwE1GAsAEA0UNRo0AhwAAAASIwoAEAwUBgAAAAAAAAAAIQQJCAwCBQ8KABANFAYAAAAAAAAAACEMAgsCBBULAAELAQIKABANFDULATUYCwAQDBQ1GjQCHQAAAAMEBgAAAAAAAAAABgAAAAAAAAAAEgECHgAAADkWCgALAREXDAMOAwoAEAUUERwMBAsAEAgUDAILBAsCIQQTBRUHCScCAAcACAAJAgECAgADAAQABgAFAAEAAgIDAQABAQBRAFIADHN0b3JhZ2VfZnVuZLUEoRzrCwYAAAALAQAGAgYOAxQsBEAIBUhJB5EBsgEIwwJACoMDDwySA2sN/QMED4EEAgAJAQQBCgACBAABAAQBAAECAQIAAAYAAQAAAwIAAAANAwQAAAwDBAABBQgEAQABCAkHAQABDgoEAQABDwUHAQAHBgQGBQYGBgELAQEIAgEIAAYHCAALAQEIAgsBAQgCCwEBCAIDAwEGCAABAwABCAIBCwEBCQACBwsBAQkACwEBCQACBwsBAQkAAwEGCwEBCQAHQmFsYW5jZQNTVUkLU3RvcmFnZUZ1bmQNYWR2YW5jZV9lcG9jaAdiYWxhbmNlBGpvaW4DbmV3Fm5vbl9yZWZ1bmRhYmxlX2JhbGFuY2UFc3BsaXQMc3RvcmFnZV9mdW5kA3N1aRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyDXRvdGFsX2JhbGFuY2UcdG90YWxfb2JqZWN0X3N0b3JhZ2VfcmViYXRlcwV2YWx1ZQR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgACAg0LAQEIAgcLAQEIAgADAAAFBDgACwASAAIBAwAAAB4KAA8ACwI4AQEKAA8ACwM4AQEKAA8BCwE4AQEKAA8BCwU4AgwGCgAPAAsGOAEBCwAPAQsEOAICAgEAAAUECwAQATgDAgMBAAAFCAoAEAE4AwsAEAA4AxYCAAEAAAALAAx2b3RpbmdfcG93ZXLoDKEc6wsGAAAADAEACAIICAMQVwRnBAVrhQEH8AGYAgiIBGAG6ARGCq4FBwy1BfcGDawMAg+uDAIAFAETAggAEAABAgADAAQAAAwAAQAABQIDAAANBAUAAAYGAQAAAgcBAAAPCAEAAAMEAQAADgEFAAALAQUAAQYRAQEAAQcTFAEAAgQLBQACCQsFAAIKCwUAAwwVAQADDQ4FAAMUDgUACQ0KDQEHCggBAAIGCggBAwIKCAADAQYKCAEBAwIHCggACAADBwoIAAMDAgcKCAEKCAAEAwoIAAMDAQgBAgMDBwMIAAMKCAADAwMBCAABBggBAwMDAwQDAQMDAwcKCQAJAAMHAQMDAwMDBwgAAQYKCQABAQIHCAEDDAMDAwMDAwMDAwYIAQYIAQMJVmFsaWRhdG9yD1ZvdGluZ1Bvd2VySW5mbxNhZGp1c3Rfdm90aW5nX3Bvd2VyEGNoZWNrX2ludmFyaWFudHMTZGl2aWRlX2FuZF9yb3VuZF91cBZpbml0X3ZvdGluZ19wb3dlcl9pbmZvBmluc2VydAhpc19lbXB0eQRtYXRoA21heANtaW4QcXVvcnVtX3RocmVzaG9sZBBzZXRfdm90aW5nX3Bvd2VyC3RvdGFsX3N0YWtlEnRvdGFsX3ZvdGluZ19wb3dlchN1cGRhdGVfdm90aW5nX3Bvd2VyCXZhbGlkYXRvcg92YWxpZGF0b3JfaW5kZXgNdmFsaWRhdG9yX3NldAZ2ZWN0b3IMdm90aW5nX3Bvd2VyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgQJwAAAAAAAAMICxoAAAAAAAADCOgDAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAACAhEDFAMAAwAACR0HAAcCBwAKAC5BChELEQwRDQwECgAKBAwBLgsBEQEMAwwCDQILBAsDEQQKAAsCEQULAC4RBgIBAAAADDcKABECDAcGAAAAAAAAAAAMAgoAQQoMBAYAAAAAAAAAAAwGQA0AAAAAAAAAAAwFCgIKBCMEMAURCgAKAkIKEQ81BwA1GAoHNRo0CgERDQwICgIKCBIADAMNBQsDEQMLBgsIFgwGCwIGAQAAAAAAAAAWDAIFDAsAAQsFBwALBhcCAgAAAA8cBgAAAAAAAAAADAEKAEEKDAIGAAAAAAAAAAAMAwoBCgIjBBgFDAsDCgAKAUIKEQ8WDAMLAQYBAAAAAAAAABYMAQUHCwABCwMCAwAAABAnBgAAAAAAAAAADAQKAC5BDQwFCgQKBSMEGQULCgAKBAwCLgsCQg0QABQOARAAFCQMAwUbCQwDCwMEIgsEBgEAAAAAAAAAFgwEBQYLAAsBCwQ4AAIEAAAAElQGAAAAAAAAAAAMBQoALkENDAYKBQoGIwQQBQsKAgYAAAAAAAAAACQMAwUSCQwDCwMESgoACgVDDQwJCgIKBgoFFxELDAcKAQoJEAAUCwcWEQ0MCAoCCwgKCRAAFBcRDQwECgkQABQKBBYKCQ8AFQsJEAAUCgElBD0FQQsAAQcFJwsCCwQXDAILBQYBAAAAAAAAABYMBQUGCwABCwIGAAAAAAAAAAAhBFEFUwcDJwIFAAAACxUOATgBIAQQBQUNAUUNEwAMAwwCCgALAkMKCwMRDgUACwABCwFGDQAAAAAAAAAAAgYAAAAWdwYAAAAAAAAAAAwDCgBBCgwEBgAAAAAAAAAADAkKAwoEIwQjBQwKAAoDQgoREAwMCgwGAAAAAAAAAAAkBBYFGgsAAQcGJwsJCwwWDAkLAwYBAAAAAAAAABYMAwUHCwkHACEEKAUsCwABBwMnBgAAAAAAAAAADAEKAQoEIwR0BTMKAQYBAAAAAAAAABYMAgoCCgQjBG8FPAoACgFCCgwKCgAKAkIKDAsKChEPDAcKCxEPDAgLChEQDAULCxEQDAYKBwoIJARdCgUKBiYEWQVdCwABBwQnCwcLCCMEagsFCwYlBGYFagsAAQcEJwsCBgEAAAAAAAAAFgwCBTcLAQYBAAAAAAAAABYMAQUuCwABAgcBAAABAgcAAggBAAABAgcBAgABABIADXN0YWtlX3N1YnNpZHmrBqEc6wsGAAAADAEADAIMFgMiJQRHBAVLSgeVAbACCMUDQAaFBBIKlwQUDKsEuwEN5gUKD/AFBAASAQYBBwEOARUBFwADBAABAAwAAgEEAQABBAICAAUEAgAACAABAAAFAgMAAAoEBQABEAcIAAIRDQ4BAAIYCwUBAAMPDAUABQoECgULAgEIAwMDDQcIBAEIAAEHCAABCwIBCAMBBggAAQMAAQcIBAEIAQMECwIBCAMDAQgDAQYLAgEJAAIDAwIHCwIBCQADAQsCAQkAA0JhZwdCYWxhbmNlA1NVSQxTdGFrZVN1YnNpZHkJVHhDb250ZXh0DWFkdmFuY2VfZXBvY2gDYmFnB2JhbGFuY2UGY3JlYXRlG2N1cnJlbnRfZGlzdHJpYnV0aW9uX2Ftb3VudBxjdXJyZW50X2Vwb2NoX3N1YnNpZHlfYW1vdW50FGRpc3RyaWJ1dGlvbl9jb3VudGVyDGV4dHJhX2ZpZWxkcwdnZW5lc2lzBG1hdGgDbWluA25ldwVzcGxpdA1zdGFrZV9zdWJzaWR5G3N0YWtlX3N1YnNpZHlfZGVjcmVhc2VfcmF0ZRtzdGFrZV9zdWJzaWR5X3BlcmlvZF9sZW5ndGgDc3VpFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIKdHhfY29udGV4dAV2YWx1ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEEBAnAAAAAAAAAAAAAAAAAAAAAgYHCwIBCAMLAwkDFAMTDQwIAQADAAAGEwoDBwBLJQQGBQoLBAEGAAAAAAAAAAAnCwAGAAAAAAAAAAALAQsCCwMLBBEDEgACAQMAAAk5CgAQABQKABABOAARBgwDCgAPAQsDOAEMAgoAEAIUBgEAAAAAAAAAFgoADwIVCgAQAhQKABADFBkGAAAAAAAAAAAhBDUKABAAFDUKABAEFDUYBwAaDAEKABAAFAsBNBcLAA8AFQU3CwABCwICAgEAAAYICgAQABQLABABOAARBgIAAgAAAAEAAwAEAA0AFgANdmFsaWRhdG9yX2NhcJkFoRzrCwYAAAALAQAIAggUAxwlBEEEBUUuB3PbAgjOA0AKjgQNDJsEQw3eBAQP4gQGABEBCgENAQ4AAwwAAAQCAAEABwABAgQAAwECAAAPAAEAABMCAQAACQMEAAAIAAUAAQYLBAEIAQcICQACCwwGAQwECgYKAQYIAAEGBQEGCAECBQcIBAEIAgEIAQACCAAIAgEHCAQBCAMBCAABBgkAAgkABQJJRAlUeENvbnRleHQDVUlEH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAVVmFsaWRhdG9yT3BlcmF0aW9uQ2FwHGF1dGhvcml6ZXJfdmFsaWRhdG9yX2FkZHJlc3MCaWQDbmV3E25ld19mcm9tX3VudmVyaWZpZWQzbmV3X3VudmVyaWZpZWRfdmFsaWRhdG9yX29wZXJhdGlvbl9jYXBfYW5kX3RyYW5zZmVyBm9iamVjdA9wdWJsaWNfdHJhbnNmZXIWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lcgh0cmFuc2Zlcgp0eF9jb250ZXh0IHVudmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzCXZhbGlkYXRvcg12YWxpZGF0b3JfY2FwDXZhbGlkYXRvcl9zZXQedmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgACAgYIAwUFAQIBBQUAAwAABgMLABAAAgEDAAAGAwsAEAECAgMAAAcNCwERBQoAEgAMAg4COAAMAwsCCwA4AQsDAgMDAAAGBQsAEAAUEgECAAEBAAAMABAAEgANdmFsaWRhdG9yX3NldPFPoRzrCwYAAAAMAQAzAjNsA58BhAYEoweFAQWoCNQJB/wRrRcIqSlgBokqkQEKmitsDIYsmCMNnk8QD65PBQCeAQFmAaYBAh0CHgI4AmQCcAKMAQKQAQKRAQKXAQKkAQKlAQCIAQCaAQCdAQCiAQCpAQASBAAADgMAAA8DAAAQAwABBAcBAAADAAwABAEEAQABBgMHAAcCBgECAAcGBgECAAgHAgAJCQwCBwEEAQoKBAEEAQsLAgAMFAcCAQAAAA0VBwEDAA4FBwAOCAgADw0EABAMDAAQEQIAERMEAABfAAEAAHsCAwAAfQQDAAB6BQMAABsGAwAAfAQDAAB5BwMAAH8IAwAAfgkDAAAaCgMAAJkBCwMAADMMAwAALg0OAACUAQ0OAAChAQ8OAACfAQ8OAACgAQ8QAACKAQ0RAABiDQ4AAFAPEgAAUwYSAABSExIAACoTDgAAVAYSAAApFA4AAEMVFgAAOxcYAAA8GRgAAEYaGwAARxwWAABAHRYAAEoeFgAASB8WAABJHxYAAEsXIAAAQSEgAABCDyAAAEUPIAAAqAEiIwAAcSQDAAB0JQMAACImAwAAcycDAACEASgDAAByKQMAACEqDgAAGSsDAAAlLC0AACYuLwAAJzAxAAAkMjEAADIzAwAANTQDAACPARoOAAAXDSoAAFkPEgAAVjUSAAEwb1EBAAE6UFEBAAFYTxIBAAFjA28BAAGDAVFvAQACKFISAQACVX0SAQACeGFRAQADXzhCAAQxlAEDAQAEW5UBDgEABIUBkwGUAQEABKMBWw4BAAU0UQMBAwZMbhABCAdfZ2gBAgdgZWYBAgdvaWUBAgkYPAMCBwQJH0RVAgcECSBJVwIHBAkoRBICBwQJXzg5AgcECXhJSgIHBAofbW4BBAogcnMBBAo2OD0BBApVahIBBApdag4BBApuhwFRAQQKdU0DAQQLN0gOAAuAAUg7AAwoXRICAQAMNgNBAgEADD9dVQIBAAxEXlcCAQAMTmADAgEADFWCARICAQAMXIIBgwECAQAMbY4BXwIBAAx4Xl8CAQAMggGCAQ4CAQANKIQBEgEDDU+PAYMBAQMNVYYBEgEDDXiFAQMBAw5pVBAADxZLAwAPGRYDAA8jIA4ADyxLAwAPLZYBAwAPMxYDAA89IA4AD1FsEgAPVyASAA9lIHsAD2yYAZkBAA9yigEDAA95UwMAD35LAwAPf1YDAA+HASAOAA+JASAQAA+NASA7AA+VASAOAA+pASAOABBheSMAEJgBeXUAEKcBdHUAEStFRgARL0Y6ABFeWBYAEnYDDgASgQErAwASlgEDDgBPN0s3UzpPPk8/W0BOP0s/UD9QN0s+Vzo7DjoOPg5ON0w3Tj5NPkVaWkBiQF1AXkBAOkkOSA5KDlU6UTpNPz0OPA45DlI6R3o/DkZ/WoEBYoEBYIEBXYEBZDtnO2Y7VDpWOkaIAVtiXmJfgQFhgQFlO2NiWmJcYkRaQ1pCWlyBAT47RpoBAgoIEgcIDQEIAAMHCAAIEgcIDQACBwgABwgNAwcIAAMHCA0CBggABggSBAcIAAULBgEICgcIDQMHCAAIEQcIDQMHCAADBggNCQcIAAcLBgEICgcLBgEICgcLDgIFCw8BBQMDAwMHCA0GBwgAAwMDBwsOAgULDwEFBwgNAQcIAAEGCAABAwIGCAAFAQgHAQYLCwIIBwUBAQIGCggSBggSAgYLDAEIEgYIEgIHCAAFAQcIEgIGCggSBQELBAEDAgYLDAEIEgUCBgoIEgYKBQEKAwIHCggSBQMHCAAFAQMHCAAGCBQBAgcIAAYIDQEGCBIDBwgABQIDBwgABggTAgEIFAMHCAAHCw4CBQsPAQUHCA0FBwgACBIHCw4CBQsPAQUBBwgNAgcLDgIFCw8BBQUCBwgAAwEHCgMCBwoIEgcIDQEGCggSAQcKCBIECgMDBgoDBgoDBAMLDgIDAwMLDgIDAwIGCAALDgIFCw8BBQIKBQMEBgoIEgMDAwIKAwoDCQYKCBIDAwoDCgMDCw4CAwMDCw4CAwMGBwoIEgYKAwYKAwcLBgEICgcLBgEICgcIDQYDBgoIEgYKAwYKAwYLDgIFCw8BBQYKBQIGCAAIBwYDAwsLAggHBQMGCBIIAAIIBwUBBwgNAQsLAgkACQEBCBIBBQMHCwsCCQAJAQkACQEBCwwBCQACCAcIFQIFCBUCBQMBCw4CCQAJAQEIBQQGCBIGCBIBBQIGCwsCCQAJAQkAAggSBwgNAQgVAwgHCBIFAQYIDQIHCwsCCQAJAQkAAQkBAgcIEgMFBggSBggSAQgSBQIHCwwBCQAJAAMFAwsEAQMBBgsEAQkAAQcLBAEJAAEJAAIGCgkABgkABAcIEgsGAQgKBQcIDQEGCBEBBgkBAwcIEggRBwgNAQcJAQEHCBUOCw4CBQsPAQUGCgUKAwoDCw4CAwMLDgIDAwMKBQMDAwMKAwoDAQgKAQYLBgEJAAgDAwcDAwgSCBIFBggSAgYLDgIJAAkBBgkAAgcLDgIJAAkBBgkAAgkACQEDBwsOAgkACQEJAAkBAgcKCQADAgMDCgoLCAEDAwMLCQEDAwMDAwYIEgYKCBIBCwgBAwIDCQABCwgBCQABCgsIAQkAAQsJAQkAAQcLCQEJAAEGCwwBCQADAwMDAgYIEgYIEgIGCwwBCQADAQYJAAELBAEJAAUFAwsEAQMDCgMEAwMLBAEDCwQBAwIHCwwBCQADAQcJAAEGCBQBBgUCAwsEAQMGAQEDAwsEAQMLBAEDBQUGCBIIBwUGCBIBBggTAQgTAQYIBwIDCBIBBgoJAAMDBQgHAQgDBwYFBgUDAwYFCgUHCw8BBQIFCw8BBQEGCw4CCQAJAQEKCQACBgsPAQkABgkAAgcLDwEJAAYJAAEGCw8BCQABBwsMAQkAAQgCBgMDAwMDAwIHCBIHCA0EAwMDBggSBwsOAgMDCw4CAwMEBAMDAwYKBQYKCBILDwEFCgUDBQEHCw4CCQAJAQELDwEJAAYDAwQKAwoDAxEDAwMKAwMKAwMEAwMDAwMEAwMDCAMDCwYBCAoDBwgSBQQLBgEICgIHCwYBCQADAQsGAQkAAgcLBgEJAAsGAQkAAgcIEgsGAQgKCAoFAwMDAwoFBggSBQIGCBIDAQgQAQgBA0JhZwdCYWxhbmNlBUVudHJ5AklEBk9wdGlvbhVQb29sVG9rZW5FeGNoYW5nZVJhdGUNUHJpb3JpdHlRdWV1ZQNTVUkJU3Rha2VkU3VpBVRhYmxlCFRhYmxlVmVjCVR4Q29udGV4dB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwCVZhbGlkYXRvchdWYWxpZGF0b3JFcG9jaEluZm9FdmVudBJWYWxpZGF0b3JKb2luRXZlbnQTVmFsaWRhdG9yTGVhdmVFdmVudBVWYWxpZGF0b3JPcGVyYXRpb25DYXAMVmFsaWRhdG9yU2V0EFZhbGlkYXRvcldyYXBwZXIGVmVjTWFwBlZlY1NldAhhY3RpdmF0ZRFhY3RpdmVfdmFsaWRhdG9ycwNhZGQaYWRqdXN0X3N0YWtlX2FuZF9nYXNfcHJpY2UNYWR2YW5jZV9lcG9jaCZhc3NlcnRfbm9fcGVuZGluZ19vcl9hY3RpY2VfZHVwbGljYXRlcxJhdF9yaXNrX3ZhbGlkYXRvcnMDYmFnB2JhbGFuY2UGYm9ycm93CmJvcnJvd19tdXQWY2FsY3VsYXRlX3RvdGFsX3N0YWtlcyZjbGVhbl9yZXBvcnRfcmVjb3Jkc19sZWF2aW5nX3ZhbGlkYXRvcg9jb21taXNzaW9uX3JhdGUkY29tcHV0ZV9hZGp1c3RlZF9yZXdhcmRfZGlzdHJpYnV0aW9uGmNvbXB1dGVfcmV3YXJkX2FkanVzdG1lbnRzKmNvbXB1dGVfc2xhc2hlZF92YWxpZGF0b3JzX2FuZF90b3RhbF9zdGFrZSZjb21wdXRlX3VuYWRqdXN0ZWRfcmV3YXJkX2Rpc3RyaWJ1dGlvbghjb250YWlucxljb3VudF9kdXBsaWNhdGVzX3RhYmxldmVjFGNvdW50X2R1cGxpY2F0ZXNfdmVjCWNyZWF0ZV92MQpkZWFjdGl2YXRlFWRlcG9zaXRfc3Rha2VfcmV3YXJkcxpkZXJpdmVfcmVmZXJlbmNlX2dhc19wcmljZQdkZXN0cm95DGRlc3Ryb3lfc29tZQxkZXN0cm95X3plcm8RZGlzdHJpYnV0ZV9yZXdhcmQaZWZmZWN0dWF0ZV9zdGFnZWRfbWV0YWRhdGEEZW1pdBtlbWl0X3ZhbGlkYXRvcl9lcG9jaF9ldmVudHMFZW1wdHkFZXBvY2gFZXZlbnQMZXh0cmFfZmllbGRzB2V4dHJhY3QOZmluZF92YWxpZGF0b3IdZmluZF92YWxpZGF0b3JfZnJvbV90YWJsZV92ZWMJZ2FzX3ByaWNlB2dlbmVzaXMDZ2V0MGdldF9hY3RpdmVfb3JfcGVuZGluZ19vcl9jYW5kaWRhdGVfdmFsaWRhdG9yX211dDBnZXRfYWN0aXZlX29yX3BlbmRpbmdfb3JfY2FuZGlkYXRlX3ZhbGlkYXRvcl9yZWYYZ2V0X2FjdGl2ZV92YWxpZGF0b3JfcmVmJWdldF9jYW5kaWRhdGVfb3JfYWN0aXZlX3ZhbGlkYXRvcl9tdXQHZ2V0X211dBlnZXRfcGVuZGluZ192YWxpZGF0b3JfcmVmFWdldF92YWxpZGF0b3JfaW5kaWNlcxFnZXRfdmFsaWRhdG9yX211dBpnZXRfdmFsaWRhdG9yX211dF93aXRoX2N0eC9nZXRfdmFsaWRhdG9yX211dF93aXRoX2N0eF9pbmNsdWRpbmdfY2FuZGlkYXRlcyNnZXRfdmFsaWRhdG9yX211dF93aXRoX3ZlcmlmaWVkX2NhcBFnZXRfdmFsaWRhdG9yX3JlZgJpZBNpbmFjdGl2ZV92YWxpZGF0b3JzBmluc2VydAlpbnRvX2tleXMiaXNfYWN0aXZlX3ZhbGlkYXRvcl9ieV9zdWlfYWRkcmVzcwxpc19kdXBsaWNhdGUWaXNfZHVwbGljYXRlX3ZhbGlkYXRvciJpc19kdXBsaWNhdGVfd2l0aF9hY3RpdmVfdmFsaWRhdG9yI2lzX2R1cGxpY2F0ZV93aXRoX3BlbmRpbmdfdmFsaWRhdG9yCGlzX2VtcHR5FWlzX2luYWN0aXZlX3ZhbGlkYXRvcgxpc19wcmVhY3RpdmUHaXNfc29tZRZpc192YWxpZGF0b3JfY2FuZGlkYXRlDGlzX3ZvbHVudGFyeQRqb2luBGtleXMGbGVuZ3RoHGxvYWRfdmFsaWRhdG9yX21heWJlX3VwZ3JhZGUDbmV3CW5ld19lbnRyeRNuZXdfZnJvbV91bnZlcmlmaWVkGm5leHRfZXBvY2hfdmFsaWRhdG9yX2NvdW50BG5vbmUGb2JqZWN0EG9wZXJhdGlvbl9jYXBfaWQGb3B0aW9uGXBlbmRpbmdfYWN0aXZlX3ZhbGlkYXRvcnMQcGVuZGluZ19yZW1vdmFscwdwb29sX2lkE3Bvb2xfc3Rha2luZ19yZXdhcmQYcG9vbF90b2tlbl9leGNoYW5nZV9yYXRlIXBvb2xfdG9rZW5fZXhjaGFuZ2VfcmF0ZV9hdF9lcG9jaANwb3AIcG9wX2JhY2sHcG9wX21heA5wcmlvcml0eV9xdWV1ZRhwcm9jZXNzX3BlbmRpbmdfcmVtb3ZhbHMkcHJvY2Vzc19wZW5kaW5nX3N0YWtlc19hbmRfd2l0aGRyYXdzGnByb2Nlc3NfcGVuZGluZ192YWxpZGF0b3JzG3Byb2Nlc3NfdmFsaWRhdG9yX2RlcGFydHVyZQlwdXNoX2JhY2sQcXVvcnVtX3RocmVzaG9sZBpyZWZlcmVuY2VfZ2FzX3N1cnZleV9xdW90ZQZyZW1vdmURcmVxdWVzdF9hZGRfc3Rha2UVcmVxdWVzdF9hZGRfdmFsaWRhdG9yH3JlcXVlc3RfYWRkX3ZhbGlkYXRvcl9jYW5kaWRhdGUYcmVxdWVzdF9yZW1vdmVfdmFsaWRhdG9yInJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvcl9jYW5kaWRhdGUbcmVxdWVzdF9zZXRfY29tbWlzc2lvbl9yYXRlFnJlcXVlc3Rfd2l0aGRyYXdfc3Rha2UGc2VuZGVyEHNldF92b3RpbmdfcG93ZXIEc2l6ZQRzb21lEXNvcnRfcmVtb3ZhbF9saXN0BXNwbGl0BXN0YWtlDHN0YWtlX2Ftb3VudAxzdGFraW5nX3Bvb2wPc3Rha2luZ19wb29sX2lkFXN0YWtpbmdfcG9vbF9tYXBwaW5ncxtzdG9yYWdlX2Z1bmRfc3Rha2luZ19yZXdhcmQDc3VpC3N1aV9hZGRyZXNzFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIdc3VtX3ZvdGluZ19wb3dlcl9ieV9hZGRyZXNzZXMFdGFibGUJdGFibGVfdmVjGnRhbGx5aW5nX3J1bGVfZ2xvYmFsX3Njb3JlF3RhbGx5aW5nX3J1bGVfcmVwb3J0ZXJzC3RvdGFsX3N0YWtlEnRvdGFsX3N0YWtlX2Ftb3VudBJ0b3RhbF92b3RpbmdfcG93ZXIKdHhfY29udGV4dCB1bnZlcmlmaWVkX29wZXJhdGlvbl9jYXBfYWRkcmVzcyd1cGRhdGVfYW5kX3Byb2Nlc3NfbG93X3N0YWtlX2RlcGFydHVyZXMJdmFsaWRhdG9yEXZhbGlkYXRvcl9hZGRyZXNzFHZhbGlkYXRvcl9jYW5kaWRhdGVzDXZhbGlkYXRvcl9jYXANdmFsaWRhdG9yX3NldBZ2YWxpZGF0b3Jfc3Rha2VfYW1vdW50GXZhbGlkYXRvcl9zdGFraW5nX3Bvb2xfaWQcdmFsaWRhdG9yX3RvdGFsX3N0YWtlX2Ftb3VudBF2YWxpZGF0b3Jfd3JhcHBlcgV2YWx1ZQd2ZWNfbWFwB3ZlY19zZXQGdmVjdG9yHnZlcmlmaWVkX29wZXJhdGlvbl9jYXBfYWRkcmVzcwp2ZXJpZnlfY2FwDHZvdGluZ19wb3dlcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIBAQIBAgIBAwQQECcAAAAAAAAAAAAAAAAAAAMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAwgFAAAAAAAAAAMIBgAAAAAAAAADCAcAAAAAAAAAAwgIAAAAAAAAAAMICQAAAAAAAAADCGUAAAAAAAAACgMBAAoFAQAAAgmUAQMXCggSZwsMAQgSaAoDigELCwIIBwVNCwsCCAcIFZwBCwsCBQgVHAsOAgUDOQgFAQIKNwObAQV3A4YBAyMDagOLAQNrCBCTAQoFkgEDAgIDNwObAQWJAQgHAwIENwObAQWJAQgHWgEAAwAANjMOABEtDAUKATgADAQOAEE6DAMGAAAAAAAAAAAMAgoCCgMjBB8FEA4ACgJCOgwGDQQKBhF5CwYRejgBCwIGAQAAAAAAAAAWDAIFCwsFCwAKATgCQA4AAAAAAAAAAAsECgE4AwoBOAQ4BQsBEUESAAwHDQcPABGEAQsHAgEDAABDRQoADgEMAy4LAxEUIAQRCgAOAQwELgsEERcgDAUFEwkMBQsFBBYFHAsAAQsCAQcGJw4BEXoMBgoAEAEKBjgGIAQmBSwLAAELAgEHCicOARFxBDAFNgsAAQsCAQcLJwoADwIOARF5CwY4AQsADwEOARF6CwELAhGAATgHAgIDAABHNQoBLhFZDAQKABABCgQ4BgQKBRALAAELAQEHDCcKAA8BCwQ4CBGBAQwDDgMRcQQaBSALAAELAQEHCycOAxF5DAIKAA8CCgI4CQENAwoBLhFYEWwLAA8DCwILAwsBEYABOAoCAwMAAExFCwIuEVkMBwoAEAEKBzgGBAoFDgsAAQcMJwoADwELBzgIEYEBDAYKAA4GDAMuCwMRFCAEJQoADgYMBC4LBBEXIAwFBScJDAULBQQqBS4LAAEHBicOBhFxBDIFNgsAAQcLJw4GEXsLASYEPAVACwABBwknCwAPBAsGOAsCBAMAAAMQCgAQAAoBERYLABAECwERGBYGAQAAAAAAAAAhBA0FDwcGJwIFAwAATiQLAS4RWQwCCgAQAAsCERoMBA4EOAwEDQURCwABBgAAAAAAAAAAJw0EOA0MAwoAEAUOAzgOIAQbBR8LAAEGAAAAAAAAAAAnCwAPBQsDRA4CBgMAAAMKCwALAREZCwIKAy4RWQsDEXUCBwMAADcrDgERaAwDCgAQAgoDOA8EFgoAEAIOARFoOBAUDAQLAAsEERkLAQsCEXcFKgoAEAMKAzgRBBwFIgsAAQsCAQcHJwsADwMLAzgSEYIBCwELAhF3AggDAAA7CgsCEVkMAwsADwALAxEdCwERdgIJAwAAWWwKCC4RWAYBAAAAAAAAABYMDwoAEAYUDBIKABAAChIKAS44EwoCLjgTETEMFgwVCgAKAxQMCS4LCREwDBEMEAoAEAAOEBEcCwQOFQ4WES8MDgwUDA0MEwoAEAALEgsRCxULFgsTCw0LFAsOETIMDAwLCgAPAA4LDgwLAQsCCggRMwoADwARLgoADwAKCBEsCg8KABAADgsODAoDDhAMCi4LChE0CgALDxEqCgAKAwoIEScKAAsFCwYLBwsDCwgRCgoAEAARLQoADwYVCgAPABGEAQsAEQsCCgAAAFxqCgAQAEE6DAcKBwYAAAAAAAAAACQEYwUJCwcGAQAAAAAAAAAXDAcKABAACgdCOgwNCg0RegwMCw0RewwJCgkKASYEKAoAEAcODDgUBCcKAA8HDgw4FQEBBWILCQoCJgRXCgAQBw4MOBQEQAoADwcODDgWDAgKCBQGAQAAAAAAAAAWCggVCwgUDAYFRwoADwcLDAYBAAAAAAAAADgXBgEAAAAAAAAADAYLBgoDJARWCgAPAAoHOBgMCgoACwoKBAkKBREoBWIKAA8ACgc4GAwLCgALCwoECQoFESgFBAsEAQsAAQsFAQILAAAAYhgKABAAQToMAgYAAAAAAAAAAAwBCgEKAiMEFQULCgAPAAoBQzoRbgsBBgEAAAAAAAAAFgwBBQYLAAECDAEAAGM8CwAQAAwKCgpBOgwDQGQAAAAAAAAAAAwBBgAAAAAAAAAADAIKAgoDIwQfBQ8KCgoCQjoMCQ0BCgkRbwsJEXw4GURkCwIGAQAAAAAAAAAWDAIFCgsKAQsBOBoMBAYAAAAAAAAAAAwHEYUBEYMBFwwIBgAAAAAAAAAADAUKBwoIIwQ6BTENBDgbDAYMBQsHCwYWDAcFLAsFAg0BAAADBAsAEAYUAg4BAAADBgsAEAALAREiEXsCDwEAAAMGCwAQAAsBESIReAIQAQAAAwYLABAACwERIhF5AhEBAAADAwsAEAICEgMAAAMMCgAQAEE6CgAQBUEOFwsAEAQ4HBYCEwMAABgICwAQAAsBERoMAg4COAwCFAAAAAMFCwAQAAsBERUCFQMAAAMGCwALAREWBgAAAAAAAAAAJAIWAAAAayEKAEE6DAMGAAAAAAAAAAAMAgYAAAAAAAAAAAwECgIKAyMEGwUMCgAKAkI6CgERcAQWCwQGAQAAAAAAAAAWDAQLAgYBAAAAAAAAABYMAgUHCwABCwEBCwQCFwAAAAMHCwAQBAsBERgGAAAAAAAAAAAkAhgAAABrIQoAOBwMAwYAAAAAAAAAAAwCBgAAAAAAAAAADAQKAgoDIwQbBQwKAAoCOB0KARFwBBYLBAYBAAAAAAAAABYMBAsCBgEAAAAAAAAAFgwCBQcLAAELAQELBAIZAAAAAxAKABABCgE4BgQLCwAPAQsBOB4RggECCwAPAAsBER0CGgAAAGIfCgBBOgwDBgAAAAAAAAAADAIKAgoDIwQbBQoKAAoCQjoRegoBIQQWCwABCwI4HwILAgYBAAAAAAAAABYMAgUFCwABOCACGwAAAGIfCgA4HAwDBgAAAAAAAAAADAIKAgoDIwQbBQoKAAoCOB0RegoBIQQWCwABCwI4HwILAgYBAAAAAAAAABYMAgUFCwABOCACHAAAAHAuCgFBOwwFBgAAAAAAAAAADAMHDwwGCgMKBSMEKAUMCgEKA0I7FAwCCgALAhEaDAQOBDgMBBkFHwsAAQsBAQcIJw0GCwQ4IUQOCwMGAQAAAAAAAAAWDAMFBwsAAQsBAQsGAh0DAABOFgoACwEMAi4LAhEaDAQOBDgMBAsFDwsAAQcIJw0EOA0MAwsACwNDOgIeAAAAcS0KABAACgERGgwFDgU4DAQQDQU4DQwDCwAPAAsDQzoCCgAQBAoBERsMBg4GOAwEIA0GOA0MBAsADwQLBDgiAgsCBCMFJwsAAQcNJwsADwELATgeEYIBAh8DAAADBwsACwERfxQLAhEeAiADAAA7CAsBEVkMAgsACwIJER4CIQMAADsICwERWQwCCwALAggRHgIiAAAAdhMKAAsBERoMAw4DOAwECAUMCwABBwgnDQM4DQwCCwALAkI6AiMDAAB3OQoAEAAKAREaDAcOBzgMBAsIDAMFDwoCBwAhDAMLAwQZDQc4DQwFCwAQAAsFQjoCCgAQBAoBERsMCA4IOAwEJAgMBAUoCwIHASEMBAsEBDINCDgNDAYLABAECwY4HQILAA8BCwE4HhGCAS4CJAEAAHYVCgAQAAsBERoMAw4DOAwECQUNCwABBgAAAAAAAAAAJw0DOA0MAgsAEAALAkI6AiUBAAB2FQoAEAQLAREbDAMOAzgMBAkFDQsAAQYAAAAAAAAAACcNAzgNDAILABAECwI4HQImAwAAeCcKARF+FAwGCgIHACEEEAsACwYMAy4LAxEkDAQFFQsACwYLAhEjDAQLBAwHCgE4IwwFCwcRcg4FIQQgBSQLAQEHDicLARF9AicAAAB8IAoADwURKwoAEAU4JCAEGQUJCgAPBUUODAMKAA8ACwM4GAwECgALBAoBCAoCESgFAwsBAQsAAQsCAQIoAAAAfjoKBC4RWAYBAAAAAAAAABYMBQ4BEXoMBg4BEXkMBwoADwIKBzgJAQoAEAcOBjgUBBwKAA8HDgY4FQEBCgAQBhQOARF7FwoADwYVCwIKBhEpCgULBg4BEXkLAxIDOCUNAQsFEWwLAA8DCwcLAQsEEYABOAoCKQAAAIABRQoADgEMAi4LAjgmBAwKAA4BOCcBAQoALjgoDAcOB0E7DAUGAAAAAAAAAAAMBAoECgUjBEIFGg4HCgRCOwwGCgAKBjgpDAgKCA4BDAMuCwM4KgQ5CggOATgrCwguOCwENgoACwY4JwEBBTgLBgEFPQsIAQsGAQsEBgEAAAAAAAAAFgwEBRULAAECKgAAADocCgAQBDgtIAQZBQYKAA8EOC4MAg0CCgERaQoBDgIReg4CEXkSAjgvCgAPAAsCRDoFAAsAAQIrAAAAiQE5CgAuQQ4MBgYBAAAAAAAAAAwECgQKBiMENgULCgAKBAwBLgsBQg4UDAMKBAwFCgUGAAAAAAAAAAAkBDEFGgsFBgEAAAAAAAAAFwwFCgAKBQwCLgsCQg4UCgMkBCkFKgUxCgAKBQoFBgEAAAAAAAAAFkcOBRULBAYBAAAAAAAAABYMBAUGCwABAiwAAABiGgoALkE6DAMGAAAAAAAAAAAMAgoCCgMjBBUFCwoACgJDOgoBEXQLAgYBAAAAAAAAABYMAgUGCwABCwEBAi0AAACLAR4GAAAAAAAAAAAMAwoAQToMAgYAAAAAAAAAAAwBCgEKAiMEGgUMCgAKAUI6DAQLAwsEEXsWDAMLAQYBAAAAAAAAABYMAQUHCwABCwMCLgAAAGIXCgAuQToMAgYAAAAAAAAAAAwBCgEKAiMEFAULCgAKAUM6EWoLAQYBAAAAAAAAABYMAQUGCwABAi8AAACMAUUGAAAAAAAAAAAMCDgwDAQGAAAAAAAAAAAMCTgwDAUNAC44JCAEPAUODQBFDgwKCgIKCkIOFDUKATUYBwMaDAYNBAoKCgY0ODELCAsGNBYMCAoDCgpCDhQ1CgE1GAcDGgwHDQULCgoHNDgxCwkLBzQWDAkFCAsDAQsCAQsICwQLCQsFAjAAAACNATEHEAwFBgAAAAAAAAAADAYOATgyIAQsBQkNATgzDAQMBwoACgcREwQSBRYLAAEHBCcKABAADAMLBDg0DAILAw4CETURgwEmBCsLBgoACgcRDhYMBg0FCwdEOwUECwABCwULBgIxAAAAkAEvQA4AAAAAAAAAAAwHQA4AAAAAAAAAAAwICgBBOgwFCwMKBRoMCQYAAAAAAAAAAAwECgQKBSMEKgUSCgAKBEI6EXs1CgI1GAoBNRoMBg0HCwY0RA4NCAoJRA4LBAYBAAAAAAAAABYMBAUNCwABCwcLCAIyAAAAkQFsCwELAhcMF0AOAAAAAAAAAAAMDEAOAAAAAAAAAAAMDgoAQToMFAoUDgY4NRcMFQYAAAAAAAAAAAwTChMKFCMEZwUXCgAKE0I6EXs1DBYOAwoTQg4UDBgOBg4TODYEMA4GDhM4NxQMDwsYCw8XDAkFPQoFNQsWGAoXNRoMEAsYCxA0FgwJCwkMCw0MCwtEDg4EChNCDhQMGQ4IDhM4NgRVDggOEzg3FAwRCxkLERcMCgVdCgcKFRoMEgsZCxIWDAoLCgwNDQ4LDUQOCxMGAQAAAAAAAAAWDBMFEgsAAQsMCw4CMwAAAJIBaQoALkE6DAcKBwYAAAAAAAAAACQECQUXCwABCwQBCwMBCwUBCwIBCwEBBgAAAAAAAAAAJwYAAAAAAAAAAAwGCgYKByMEXAUeCgAKBkM6DAoKAQoGQg4UDAkKAwoJODgMCAsJNQoKLhFrNRgHAxoMDA0ICww0ODgMDQ0NCgQKAgoGQg4UODg4OQEODTgTBgAAAAAAAAAAJARSCgouEXoMCwoKCw0LCwoFEXUFVAsNODoLCgsIEW0LBgYBAAAAAAAAABYMBgUZCwABCwQBCwMBCwUBCwIBCwEBAjQAAACXAVIKAUE6DAkGAAAAAAAAAAAMCAoICgkjBEcFCgoBCghCOgwMCgwRegwNCgQODTgmBBwKBA4NODsUODQMBgUeBxAMBgsGDAsKBQ4NODwEJwYAAAAAAAAAAAwHBSkGAQAAAAAAAAAMBwsHDAoKAAsNCgwRbwoMEXsKDBFrCgIKCEIOFAoDCghCDhQLDAoAEXMLCwsKEgE4PQsIBgEAAAAAAAAAFgwIBQULAQELAwELBQELBAELAgECNQEAAIsBIwYAAAAAAAAAAAwEBgAAAAAAAAAADAIKAUE7DAMKAgoDIwQdBQwKAAoBCgJCOxQRIgwFCwQLBRF8FgwECwIGAQAAAAAAAAAWDAIFBwsAAQsBAQsEAjYBAAADAwsAEAACNwEAAAMFCwAQAQsBOAYCOAEAAAMFCwAQAwsBOBECAAEABgAEAAUAAgADAAAABwA+AI4BABF2YWxpZGF0b3Jfd3JhcHBlcsMEoRzrCwYAAAAMAQAIAggQAxgwBEgGBU40B4IB0wEI1QJABpUDCgqfAwYMpQNkDYkEAg+LBAIADgEKARAADAACBAABAAIAAgMMAAMBBAAABQABAAAIAgMAAAYBBAAACwIFAAAPBgcAAgQICQEEAgYJDAEEAgkKCwEEAg8NBwAFBAcEBgQCCAMHCAEBCAABBwgAAQcIAwEIAwABBggAAQMDAwkABwgBAQgCAQcIAgEHCQABCQABBggCCVR4Q29udGV4dAlWYWxpZGF0b3IQVmFsaWRhdG9yV3JhcHBlcglWZXJzaW9uZWQGY3JlYXRlCWNyZWF0ZV92MQdkZXN0cm95BWlubmVyHGxvYWRfdmFsaWRhdG9yX21heWJlX3VwZ3JhZGUObG9hZF92YWx1ZV9tdXQKdHhfY29udGV4dBF1cGdyYWRlX3RvX2xhdGVzdAl2YWxpZGF0b3INdmFsaWRhdG9yX3NldBF2YWxpZGF0b3Jfd3JhcHBlcgd2ZXJzaW9uCXZlcnNpb25lZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAAIBBwgCAAMAAAUGBgEAAAAAAAAACwALATgAEgACAQMAAAUGCgARAwsADwA4AQICAwAABQYNABEDCwATADgCAgMAAAAFCgsALhEEBgEAAAAAAAAAIQQHBQkHACcCBAAAAAUECwAQABEIAgAAAA0AFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXKFP6Ec6wsGAAAADAEALQItYAONAcsFBNgGMgWKB9kGB+MN/BwI3ypgBr8rjQEKzCxrDLct4xANmj4qD8Q+BABtAUECFwIYAhkCJQJAAkMCawJvAnUCdgKqAQKrAQBhAGQAZwCdAQCeAQCiAQALBAAACQQAAAoDAAEEBwEAAAIADAADAQQBAAEEAgwBAAEGAwcACAUCAAkMDAIHAQQBCw0CAAwSBwIBAAAADRMHAQMADgYEAA8HCAAQCAQAEQ8EABIODAASEAIAExEEAAAbAAEAABwCAwAATQQFAABPBgUAAEwGBQAATgYFAABRBwUAAF0HBQAAUAgFAABcCAUAAEoJBQAASwoFAABSCwUAAEgMBQAAdwwFAABJDQUAAHgNBQAAUwYFAACUAQ4FAACSAQ4FAACTAQ4FAACcAQ4FAACVAQ4FAAB+DgUAAJcBDgUAAIABDgUAAJgBDgUAAIEBDgUAAJoBDgUAAIMBDgUAAJkBDwUAAIIBDwUAAJsBDgUAAIQBDgUAAJYBDgUAAH8OBQAAFBARAAAVEgUAACITFAAARBMUAABuExQAACoFFAAAJBMUAACjARUUAACkARUWAAClARMXAAAtFRgAAC8TFAAALhMUAAAnGREAAR5cPgEAATdbOQEAAj0jJAADHyIFAQADOE8UAQADX1MiAQADqQFRFAEAA64BTiIBAAOvAQUiAQAEKF00AQAENDQiAQAFID4FAQMHOVoFAQAKRV4FAQwLIiYUAAtZJicADBo9OQIBAAwhBSACAQAMKz1XAgEADCxBQgIBAAwzQAUCAQAMR0FHAgEADRpDOQEDDSEFPwEDDTNEBQEDDTZGOQEDDUdFBQEDDV4+PwEDDhRSEQAPYDYUABAUVREAED0RHgAQcFAUABByUBQAET0oJQARPkgFABFRMAUAEVozBQARWzAFABF5SQUAEXpJBQARe0kFABF8SQUAEX1MBQARhQFJBQARhgFJBQARhwFJBQARiAFJBQARiQFJBQARigFJBQARiwFJBQARjAFJBQARjQFJBQARjgFMBQARjwFJBQARkAFJBQARkQFJBQASrAE7PAATFFQFABMWSwUAEx0dFAATMDIvABMxMi8AEzIuLwATNTg5ABM9GxwAEz8dFAATSjUFABNMKwUAE00pBQATTioFABNPKgUAE1AxBQATUjcFABNlHRcAE3MdFAATpAE4FgATpgE4FAATrQEtLABDHzohPCFCH00nRh9FH0gnSidMJ0snRx85ITYhOCE3IT1WRB9JJz4hMxQyFDshP1k1IQcKCBALBQEICAMDCAAIDQcICgEIAQgDAwMDAwMDBwgKAQgAEAcIAQoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgKAAIHCAEHCAoDBwgBBggRAwMHCAEDBwgKBAcIAQsGAQgIBQcICgUHCAEKCwYBCAgLAwEDBQcICgMHCAEIDgcICgMHCAEGCBEFAwgSBQcLCwIFCwwBBQMHCAEKAgYICgQHCAEKAgoCBggKCwcIAQMDCwUBCAgLBQEICAMDAwMDBwgKAQsFAQgICAcIAQMDCwUBCAgLBQEICAMDBwgKAQYIAQEDAgYIAQUBCAcBBgsJAggHBQELDAEFAwoLBgEICAsDAQMHCAoCAwgTAgoIEAcICgEIEwEGCBMBCA8CBQsMAQUBCwsCCQAJAQEICAELBQEJAAEHCAoBCAQBCBABBggKAQUQBQoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgKAwcIEwgQBwgKAgcIEwcICgMHCBMDBwgKAQgSAwcIEwYIEQIDBwgTBggSAQEHCBADBwgQCBIDAwcIEwMGCAoCBwgTBggKAgcIEAMBCwYBCQAEBwgTBQsFAQgIBwgKAQYIDgMHCBMIDgcICgIGCBMFAQEEBgUGBQUHCwwBBQEGCBIBBgUCBgsLAgkACQEGCQABCQABCwwBCQADBwsLAgkACQEJAAkBAgcLCwIJAAkBBgkAAQcJAQIGCwwBCQAGCQACBwsMAQkACQACBwsMAQkABgkAAQYLDAEJAAIJAAkBAgcIEAcICgIHCBAKAgIHCBAGCBACBggTBggQAwcIEAoCCgIqAQMDAwMDAQELBQEICAMDAwMDAwMDAwQDAwMLBQEICAMDCwUBCAgLBQEICAsFAQgICwUBCAgDAwMLBQEICAQLBQEICAQDAwMDBAMBBwsFAQkAAgcLBQEJAAsFAQkAAQYIDwEGCwUBCQABBwgNAgcLBQEJAAMJBwgTBwsFAQgIBwsFAQgIBwsLAgULDAEFAwMDAwcICgYHCA8LBQEICAsFAQgICwUBCAgDAwEIAgEGCQEFCwUBCAgDCwUBCAgLBgEICAsFAQgIAQsGAQgIAgcLBgEJAAoLBgEJAAEGCwMBCQABCwMBCQACCwUBCQAHCAoCCQAFA0JhZwdCYWxhbmNlBENvaW4CSUQGT3B0aW9uA1NVSQxTdGFrZVN1YnNpZHkJU3Rha2VkU3VpC1N0b3JhZ2VGdW5kE1N1aVN5c3RlbVN0YXRlSW5uZXIUU3lzdGVtRXBvY2hJbmZvRXZlbnQQU3lzdGVtUGFyYW1ldGVycwVUYWJsZQlUeENvbnRleHQfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAlWYWxpZGF0b3IVVmFsaWRhdG9yT3BlcmF0aW9uQ2FwDFZhbGlkYXRvclNldAZWZWNNYXAGVmVjU2V0DWFkdmFuY2VfZXBvY2gXYWR2YW5jZV9lcG9jaF9zYWZlX21vZGUmYXNzZXJ0X25vX3BlbmRpbmdfb3JfYWN0aWNlX2R1cGxpY2F0ZXMDYmFnB2JhbGFuY2UEY29pbghjb250YWlucwZjcmVhdGUYY3JlYXRlX3N5c3RlbV9wYXJhbWV0ZXJzGmRlcml2ZV9yZWZlcmVuY2VfZ2FzX3ByaWNlDGRlc3Ryb3lfc29tZQxkZXN0cm95X3plcm8EZW1pdAVlbXB0eQVlcG9jaBFlcG9jaF9kdXJhdGlvbl9tcxhlcG9jaF9zdGFydF90aW1lc3RhbXBfbXMFZXZlbnQMZXh0cmFfZmllbGRzFGV4dHJhY3RfY29pbl9iYWxhbmNlDGZyb21fYmFsYW5jZQdnZW5lc2lzHGdlbmVzaXNfc3lzdGVtX3N0YXRlX3ZlcnNpb24DZ2V0B2dldF9tdXQQZ2V0X3JlcG9ydGVyc19vZh9nZXRfc3RvcmFnZV9mdW5kX29iamVjdF9yZWJhdGVzHmdldF9zdG9yYWdlX2Z1bmRfdG90YWxfYmFsYW5jZRpnZXRfdmFsaWRhdG9yX211dF93aXRoX2N0eC9nZXRfdmFsaWRhdG9yX211dF93aXRoX2N0eF9pbmNsdWRpbmdfY2FuZGlkYXRlcyNnZXRfdmFsaWRhdG9yX211dF93aXRoX3ZlcmlmaWVkX2NhcAZpbnNlcnQMaW50b19iYWxhbmNlImlzX2FjdGl2ZV92YWxpZGF0b3JfYnlfc3VpX2FkZHJlc3MIaXNfZW1wdHkHaXNfc29tZQRqb2luCGpvaW5fdmVjHGxlZnRvdmVyX3N0b3JhZ2VfZnVuZF9pbmZsb3cTbWF4X3ZhbGlkYXRvcl9jb3VudBttaW5fdmFsaWRhdG9yX2pvaW5pbmdfc3Rha2UDbmV3M25ld191bnZlcmlmaWVkX3ZhbGlkYXRvcl9vcGVyYXRpb25fY2FwX2FuZF90cmFuc2ZlchpuZXh0X2Vwb2NoX3ZhbGlkYXRvcl9jb3VudAZvYmplY3QGb3B0aW9uCnBhcmFtZXRlcnMDcGF5EHByb3RvY29sX3ZlcnNpb24PcHVibGljX3RyYW5zZmVyE3JlZmVyZW5jZV9nYXNfcHJpY2UGcmVtb3ZlEHJlcG9ydF92YWxpZGF0b3IVcmVwb3J0X3ZhbGlkYXRvcl9pbXBsEXJlcXVlc3RfYWRkX3N0YWtlGnJlcXVlc3RfYWRkX3N0YWtlX211bF9jb2luFXJlcXVlc3RfYWRkX3ZhbGlkYXRvch9yZXF1ZXN0X2FkZF92YWxpZGF0b3JfY2FuZGlkYXRlGHJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvciJyZXF1ZXN0X3JlbW92ZV92YWxpZGF0b3JfY2FuZGlkYXRlG3JlcXVlc3Rfc2V0X2NvbW1pc3Npb25fcmF0ZRVyZXF1ZXN0X3NldF9nYXNfcHJpY2UWcmVxdWVzdF93aXRoZHJhd19zdGFrZRRyb3RhdGVfb3BlcmF0aW9uX2NhcAlzYWZlX21vZGUdc2FmZV9tb2RlX2NvbXB1dGF0aW9uX3Jld2FyZHMkc2FmZV9tb2RlX25vbl9yZWZ1bmRhYmxlX3N0b3JhZ2VfZmVlGXNhZmVfbW9kZV9zdG9yYWdlX3JlYmF0ZXMZc2FmZV9tb2RlX3N0b3JhZ2VfcmV3YXJkcwZzZW5kZXIdc2V0X2NhbmRpZGF0ZV9jb21taXNzaW9uX3JhdGUXc2V0X2NhbmRpZGF0ZV9nYXNfcHJpY2Unc2V0X2NhbmRpZGF0ZV92YWxpZGF0b3JfY29tbWlzc2lvbl9yYXRlIXNldF9jYW5kaWRhdGVfdmFsaWRhdG9yX2dhc19wcmljZQlzaW5nbGV0b24Fc3BsaXQWc3Rha2VfYWN0aXZhdGlvbl9lcG9jaA1zdGFrZV9zdWJzaWR5FHN0YWtlX3N1YnNpZHlfYW1vdW50GXN0YWtlX3N1YnNpZHlfc3RhcnRfZXBvY2gMc3Rha2luZ19wb29sFXN0YWtpbmdfcG9vbF9tYXBwaW5ncw5zdG9yYWdlX2NoYXJnZQxzdG9yYWdlX2Z1bmQUc3RvcmFnZV9mdW5kX2JhbGFuY2UZc3RvcmFnZV9mdW5kX3JlaW52ZXN0bWVudA5zdG9yYWdlX3JlYmF0ZQNzdWkKc3VpX3N5c3RlbRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyFHN5c3RlbV9zdGF0ZV92ZXJzaW9uBXRhYmxlDXRvdGFsX2JhbGFuY2UOdG90YWxfZ2FzX2ZlZXMcdG90YWxfb2JqZWN0X3N0b3JhZ2VfcmViYXRlcwt0b3RhbF9zdGFrZR90b3RhbF9zdGFrZV9yZXdhcmRzX2Rpc3RyaWJ1dGVkCHRyYW5zZmVyCnR4X2NvbnRleHQVdW5kb19yZXBvcnRfdmFsaWRhdG9yGnVuZG9fcmVwb3J0X3ZhbGlkYXRvcl9pbXBsIHVwZGF0ZV9jYW5kaWRhdGVfbmV0d29ya19hZGRyZXNzH3VwZGF0ZV9jYW5kaWRhdGVfbmV0d29ya19wdWJrZXkcdXBkYXRlX2NhbmRpZGF0ZV9wMnBfYWRkcmVzcyB1cGRhdGVfY2FuZGlkYXRlX3ByaW1hcnlfYWRkcmVzcyB1cGRhdGVfY2FuZGlkYXRlX3Byb3RvY29sX3B1YmtleSp1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9uZXR3b3JrX2FkZHJlc3MpdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfbmV0d29ya19wdWJrZXkmdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcDJwX2FkZHJlc3MqdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcHJpbWFyeV9hZGRyZXNzKnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3Byb3RvY29sX3B1YmtleSl1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl93b3JrZXJfYWRkcmVzcyh1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl93b3JrZXJfcHVia2V5H3VwZGF0ZV9jYW5kaWRhdGVfd29ya2VyX2FkZHJlc3MedXBkYXRlX2NhbmRpZGF0ZV93b3JrZXJfcHVia2V5EnVwZGF0ZV9kZXNjcmlwdGlvbhB1cGRhdGVfaW1hZ2VfdXJsC3VwZGF0ZV9uYW1lIXVwZGF0ZV9uZXh0X2Vwb2NoX25ldHdvcmtfYWRkcmVzcyB1cGRhdGVfbmV4dF9lcG9jaF9uZXR3b3JrX3B1YmtleR11cGRhdGVfbmV4dF9lcG9jaF9wMnBfYWRkcmVzcyF1cGRhdGVfbmV4dF9lcG9jaF9wcmltYXJ5X2FkZHJlc3MhdXBkYXRlX25leHRfZXBvY2hfcHJvdG9jb2xfcHVia2V5IHVwZGF0ZV9uZXh0X2Vwb2NoX3dvcmtlcl9hZGRyZXNzH3VwZGF0ZV9uZXh0X2Vwb2NoX3dvcmtlcl9wdWJrZXkSdXBkYXRlX3Byb2plY3RfdXJsHHVwZGF0ZV92YWxpZGF0b3JfZGVzY3JpcHRpb24adXBkYXRlX3ZhbGlkYXRvcl9pbWFnZV91cmwVdXBkYXRlX3ZhbGlkYXRvcl9uYW1lK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9uZXR3b3JrX2FkZHJlc3MqdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX25ldHdvcmtfcHVia2V5J3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wMnBfYWRkcmVzcyt1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfcHJpbWFyeV9hZGRyZXNzK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wcm90b2NvbF9wdWJrZXkqdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3dvcmtlcl9hZGRyZXNzKXVwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF93b3JrZXJfcHVia2V5HHVwZGF0ZV92YWxpZGF0b3JfcHJvamVjdF91cmwJdmFsaWRhdG9yDXZhbGlkYXRvcl9jYXAgdmFsaWRhdG9yX2xvd19zdGFrZV9ncmFjZV9wZXJpb2QddmFsaWRhdG9yX2xvd19zdGFrZV90aHJlc2hvbGQYdmFsaWRhdG9yX3JlcG9ydF9yZWNvcmRzDXZhbGlkYXRvcl9zZXQWdmFsaWRhdG9yX3N0YWtlX2Ftb3VudBl2YWxpZGF0b3Jfc3Rha2luZ19wb29sX2lkH3ZhbGlkYXRvcl9zdGFraW5nX3Bvb2xfbWFwcGluZ3McdmFsaWRhdG9yX3RvdGFsX3N0YWtlX2Ftb3VudCJ2YWxpZGF0b3JfdmVyeV9sb3dfc3Rha2VfdGhyZXNob2xkCnZhbGlkYXRvcnMFdmFsdWUHdmVjX21hcAd2ZWNfc2V0HnZlcmlmaWVkX29wZXJhdGlvbl9jYXBfYWRkcmVzcwp2ZXJpZnlfY2FwDHdpdGhkcmF3X2FsbAR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgEBAgECAgEDAwgBAAAAAAAAAAMIAAAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAAEEBAnAAAAAAAAAAAAAAAAAAAFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIIIwNjAzsDPAOgAQOnAQOfAQMmCAQBAhAiA0QDbgOoAQgTZwgPQggARgOhAQsLAgULDAEFYQgNVAFYCwUBCAhVCwUBCAhXA1YDJAMmCAQCAgwiA0QDRgNzA2kDZgNqA2gDYgNxA3QDOgMAAwAAGhsLAAoGEXMMCA4IEW4MBwYAAAAAAAAAAAsCESkLCAsBEVELBAsHOAALBQk4ATgBBgAAAAAAAAAABgAAAAAAAAAACwMLBhE0EgECAQMAAAULCwALAQsCCwMLBAsFCwYLBxE0EgACAgMAACUaCg8uEUELAQsCCwMLBAsFCwYLBwsICwkLCgsLCwwLDQsOCg8RVAwQCwAPAAsQCw8RdwIDAwAABQULAA8ACwEReQIEAwAABRkKABAAEXQKABABEAIUIwQKBRALAAELAQEHAycKAA8ACwAQARADFAsBEXYCBQMAAAUFCwAPAAsBEXgCBgMAACwPCgAPAAsBBwERgAEMAwsADwAOAwkRcQsDCwIRVgIHAwAALA8KAA8ACwEHAhGAAQwDCwAPAA4DCBFxCwMLAhFYAggDAAAFBwsADwALAQsCLhF6AgkDAAAFCAsADwALAi4RcAsBEVcCCgMAAAUICwAPAAsCCwE4AgsDEXUCCwMAABEMCwELAgoEETEMBQsADwALAwsFCwQRdQIMAwAABRQOARFPCgIuEUAlBAgFDgsAAQsCAQYAAAAAAAAAACcLAA8ACwELAhF7Ag0DAAAFFgoAEAAKAhFyBAYFDAsAAQsBAQcEJwoADwALAQcAEYABCwILAA8EEQ8CDgMAAAUKCgAPAAsBBwARgAELAgsADwQREAIPAAAAOi4OABFrFAwFCgUKASIECQUNCwIBBwYnCgIOAQwDLgsDOAMgBBsLAgsBCwU4BDgFBS0LAg4BOAYMBgoGDgUMBC4LBDgHIAQrCwYLBTgIBS0LBgECEAAAADoyCgIOAQwDLgsDOAMECAUMCwIBBwcnCgIOATgGDAYOABFrFAwFCgYOBQwELgsEOAcEHAUiCwIBCwYBBwcnCgYOBTgJCwYuOAoELwsCDgE4CwEBBTELAgECEQMAAAUICwAPAAoBLhFwCwERVQISAwAABQcLAA8ACwIRcAsBEWICEwMAAAUHCwAPAAsCEXALARFgAhQDAAAFBwsADwALAhFwCwERYQIVAwAABQcLAA8ACwIRcAsBEWoCFgMAAEoQCgAPAAsCEW8MAwoDCwERYwsDLgwECwAQAAsEEW0CFwMAAAUHCwAPAAsCEXALARFZAhgDAABKEAoADwALAhFvDAMKAwsBEWULAy4MBAsAEAALBBFtAhkDAAAFBwsADwALAhFwCwERWwIaAwAABQcLAA8ACwIRbwsBEWYCGwMAAAUHCwAPAAsCEXALARFcAhwDAAAFBwsADwALAhFvCwERaAIdAwAABQcLAA8ACwIRcAsBEV4CHgMAAEoRCgAPAAsDEW8MBAoECwELAhFnCwQuDAULABAACwURbQIfAwAABQgLAA8ACwMRcAsBCwIRXQIgAwAAShAKAA8ACwIRbwwDCgMLARFpCwMuDAQLABAACwQRbQIhAwAABQcLAA8ACwIRcAsBEV8CIgMAAEoQCgAPAAsCEW8MAwoDCwERZAsDLgwECwAQAAsEEW0CIwMAAAUHCwAPAAsCEXALARFaAiQDAABNvgILCQoADwUVBws0DBsKBwobJQQQCggLGyUMCwUSCQwLCwsEFQUbCwABCwoBBwgnCgAPBjgMDCYNAwsmOA0BCgAPBzgMDCUNBAslOA0BCwUKABAIFBYMBQYAAAAAAAAAAAoADwgVCwYKABAJFBYMBgYAAAAAAAAAAAoADwkVCgAQABF9DDQKABAKEVIMKgoqCzQWDDIOAzgODCkOBDgODBwKCi4RQAoAEAEQCxQmBF8KAA8MEU4MEwVhOAEMEwsTDCcOJzgODCgNBAsnOA0BCzI1DDMKHDUMHQsqNQsdGAszGgwuDQQKLjQ4DwwtCy4LBzUYBwsaDCwNLQosNDgPDCsKABANFAYBAAAAAAAAABYKAA8NFQsBCgAQDRQhBJcBBZ0BCwABCwoBBgAAAAAAAAAAJw4EOA4MHw4tOA4MMAoADwANBA0tCgAPBAsICgAQARAOFAoAEAEQDxQKABABEBAUCwoRbAoAEAARfQwjDgQ4DgweDi04DgwvCx8LHhcMIAswCy8XDDELAgoADxEVCgAQABFuCgAPEhULLQwhDSELBDgNAQ4hOA4MIgoADwoLAwsrCyEKBQsGEVAMJAoAEA0UDBQKABARFAwVCgAQEhQMFgsjDBcLKQwYCyw0DBkLBQwaCgAQChFSDAwLKAwNCxwMDgsgCzEWDA8LIgwQCxQLFQsWCxcLGQsYCxoLDAsNCw4LDwsQEgI4EAkKAA8TFQoAEAgUBgAAAAAAAAAAIQSoAgoAEAY4DgYAAAAAAAAAACEMEQWqAgkMEQsRBLMCCwAQBzgOBgAAAAAAAAAAIQwSBbcCCwABCQwSCxIEugIFvAIHCicLJAIlAwAABTILBy4RQQcMIQQHBQsLAAEGAAAAAAAAAAAnCwEKAA8NFQsCCgAPERUICgAPExUKAA8GCwM4DQEKAA8HCwQ4DQEKABAIFAsFFgoADwgVCgAQCRQLBhYLAA8JFQImAwAABQQLABANFAInAwAABQQLABARFAIoAwAABQQLABAUFAIpAwAABQIHAwIqAwAABQQLABAFFAIrAwAABQULABAACwERfwIsAwAABQULABAACwERfgItAwAABQQLABAAEXwCLgMAABgSCgAQBA4BOAMEDAsAEAQOATgRFAwCBRALAAE4EgwCCwICLwMAAAUECwAQChFSAjADAAAFBAsAEAoRUwIxAAAAWC0NAEVZDAYNBgsAOBMLBjgCDAcOATgUBCcLATgVDAQNBwsEOA8MBQ4HOA4GAAAAAAAAAAAkBCALBwoCOBYLAi4RQTgXBSQLAgELBzgYCwUMAwUrCwIBCwcMAwsDAgEDAQUAAgADAQcBDgEKAQsBDAENAQQAAQEIAQAABAAFAAYBAQEGAQkBAgApAGwAGQ12YWxpZGF0b3JfY2FwH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3JfY2FwFVZhbGlkYXRvck9wZXJhdGlvbkNhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbAtTdGFraW5nUG9vbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbBVQb29sVG9rZW5FeGNoYW5nZVJhdGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wJU3Rha2VkU3VpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJdmFsaWRhdG9yEVZhbGlkYXRvck1ldGFkYXRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJdmFsaWRhdG9yCVZhbGlkYXRvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCXZhbGlkYXRvchNTdGFraW5nUmVxdWVzdEV2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJdmFsaWRhdG9yFVVuc3Rha2luZ1JlcXVlc3RFdmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHZvdGluZ19wb3dlcg9Wb3RpbmdQb3dlckluZm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxF2YWxpZGF0b3Jfd3JhcHBlchBWYWxpZGF0b3JXcmFwcGVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX3NldAxWYWxpZGF0b3JTZXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0F1ZhbGlkYXRvckVwb2NoSW5mb0V2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX3NldBJWYWxpZGF0b3JKb2luRXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0E1ZhbGlkYXRvckxlYXZlRXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdG9yYWdlX2Z1bmQLU3RvcmFnZUZ1bmQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw1zdGFrZV9zdWJzaWR5DFN0YWtlU3Vic2lkeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIQU3lzdGVtUGFyYW1ldGVycwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXITU3VpU3lzdGVtU3RhdGVJbm5lcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIUU3lzdGVtRXBvY2hJbmZvRXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwpzdWlfc3lzdGVtDlN1aVN5c3RlbVN0YXRlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMHZ2VuZXNpcxhHZW5lc2lzVmFsaWRhdG9yTWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwdnZW5lc2lzFkdlbmVzaXNDaGFpblBhcmFtZXRlcnMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwdnZW5lc2lzGVRva2VuRGlzdHJpYnV0aW9uU2NoZWR1bGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwdnZW5lc2lzD1Rva2VuQWxsb2NhdGlvbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwpzdWlfc3lzdGVtDlN1aVN5c3RlbVN0YXRlAAAAAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQEAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFY2xvY2sFQ2xvY2sAAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAAAAAAAAAAACAAAAAAAAAAAAAAEBAAAAAAAAAAAoBhfFq5KTB3Sg72T7dIZ8u//sty9MRies/L4aK/KKO7oAAENP15RqAADryO4/QFGceeOk2KAPSBlUUt/89L9r8AMD4RctXKBQ9gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9jYXAfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAABAAAAAAAAAABACW/+CUtATqdE44JtVHM/G0pIvlMDB/xvW+ue2JSklajPRByVW5lk1lCsBsDxWO5kI/HreBP/9pSwsGjcHsT7NQDPRByVW5lk1lCsBsDxWO5kI/HreBP/9pSwsGjcHsT7NQAAAgAAAAAAAAAAAFAMIGScX0yY1VAJPZNbuQHtiTGXpIZzfN+EzA6XXuCNyNBT1bT1kxlJ0tHUcatIvc5bTUErBT9Ilw4eZeAx6IRSAAAAAAAAAAAAAILf5A1HAAAzCOphe7deTgNZmGK/P0Lh2XY3MCG+OiSMn2uMrXHdjQAAAQEAAAAAAAAAACgRxpbj2GTO2GdKEi0SgZFwFRFPIcTf2+jjvqslrcs00AAAQ0/XlGoAAP76WriGeo/qTpa8oRk+03LVp72M8AqN8yMCvnlgfpA8AAABAQAAAAAAAAAAKBpiRlxgUjt2YQebdwdxZlg+cj2T4aYKb5y1M+4WagLIAABDT9eUagAA68juP0BRnHnjpNigD0gZVFLf/PS/a/ADA+EXLVygUPYAAAEBAAAAAAAAAAAoIOVVViuOEXgYNH2lXswn3x7tx5wPRt6BVagPtONxWxwAAENP15RqAADryO4/QFGceeOk2KAPSBlUUt/89L9r8AMD4RctXKBQ9gAAAQEAAAAAAAAAACghLwmXiQPhXJgKz/CK6gg7xTI3jNIl/3dk8pDBJ5v08QAAQ0/XlGoAAM5N7/6eit3JwfjRhF3OO7gTNEhDWeoJpY84qXzRkfDrAAABAQAAAAAAAAAAKC3xpx+qvVbb1ZOMLnqa+nnbotz+WShAQ3jVoUrNzTIBAABDT9eUagAA/vpauIZ6j+pOlryhGT7TctWnvYzwCo3zIwK+eWB+kDwAAAEBAAAAAAAAAAAoLtmDgyOkhZgMafPBALx/0dHJUls7I4qCX+QOUxk37m4AAENP15RqAABCz13CyTc6uqqEPAc0LyLdozxFtcxLV14jAmed131fcQAAAQEAAAAAAAAAAChARgSGkRd2yD2KJHWIn2TPLsZCdE0YuTm6Q0b+R4lLkgAAQ0/XlGoAAM5N7/6eit3JwfjRhF3OO7gTNEhDWeoJpY84qXzRkfDrAAABAQAAAAAAAAAAKErbNUMce/17rcgujTPLnFunjIsQM0c98Jq5fYaOItTnAABDT9eUagAA/vpauIZ6j+pOlryhGT7TctWnvYzwCo3zIwK+eWB+kDwAAAEBAAAAAAAAAAAoTLZ+HbYjnQEizRbqANQTzPeJSvKAyT0ID3YHVVa0FCUAAENP15RqAABCz13CyTc6uqqEPAc0LyLdozxFtcxLV14jAmed131fcQAAAQEAAAAAAAAAAChRtvfQE+ZTbDkfcUw+PiFVLl6mUABS3j452mwmUij0CAAAQ0/XlGoAAELPXcLJNzq6qoQ8BzQvIt2jPEW1zEtXXiMCZ53XfV9xAAABAQAAAAAAAAAAKFR6bs83sCCWX6WzwyNXGHxt/GmIAm6LQgQ9qVWtIaORAABDT9eUagAAQs9dwsk3OrqqhDwHNC8i3aM8RbXMS1deIwJnndd9X3EAAAIAAAAAAAAAAABQVTAkzhJ1VMSQcTJgHy6A39fFTtFL/83wY4Z6L/StA17VhyudSdMxhbFuc70OO3KEEM872frOhUNf4YgXGnQliQAAAAAAAAAAAACC3+QNRwAAhXZMwu8zqjK7l2LTrcXHM6ysb8EsMa+vgC16VwFTqIwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZvYmplY3QCSUQABAAAAAAAAAAAAGBqXoGk7yFzHZLVZ7++XlqsTSc9Tn2fhVnTLcvhLU+65z8CNNvXmcfsRm2TPzYDK0CkT0dfsziqDkYpmOTnEsMZz0QclVuZZNZQrAbA8VjuZCPx63gT//aUsLBo3B7E+zUBnUh1hNPnFRu/LdM136x23spEaAtGRd3TOy428+rdgjwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchNTdWlTeXN0ZW1TdGF0ZUlubmVyAAAAAAAAAAAAAJ8aavKit8pgv3YXSt/T6cSVf46Td1lgMYL5tGx/bF8ZxtIBAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAACH6TNxwBBM9EHJVbmWTWUKwGwPFY7mQj8et4E//2lLCwaNwexPs1YI3P9tFVBAplb0gZsTERtSxXRqhrpy85X7r+LsOEfR6BQOYkp1H99rXyBQvHIFz50wAEyQsMdAr/0ybOZzzCsjotJNU+Kv6yht/GaP1AYAidbSsXt5ndNvkNMy5Up6M41CBmnkTFl3N75K/2bnUrYcT8GVyFv1znTs+T3SSqlHJtPSA+xgcJSknwSa5zfZbWRU0V7gLjuC75jw4QJSg/gf6S1zCgFojv9P9Qw7ncVg+zBDUkAd8H/9ngLJfOCc3f//gzodN+15WOwnN1WoNSqbDsv1ULdmFsaWRhdG9yLTEAAAAdL2lwNC8xMjcuMC4wLjEvdGNwLzM4NDc3L2h0dHAYL2lwNC8xMjcuMC4wLjEvdWRwLzQzMzk5GC9pcDQvMTI3LjAuMC4xL3VkcC8zNTc3NxgvaXA0LzEyNy4wLjAuMS91ZHAvMzUwNzcAAAAAAAAAAKqXU15s13nyZ2Y/5JR3FX3ANNgPbfym37QB+HdGn3J8AAAAAAAAAADECQAAAAAAAAlv/glLQE6nROOCbVRzPxtKSL5TAwf8b1vrntiUpJWoAQAAAAAAAAA/AjTb15nH7EZtkz82AytApE9HX7M4qg5GKZjk5xLDGQEAAAAAAAAAAAAAAILf5A1HAAAAAAAAAAAAAACC3+QNRwCBSSC2ORwhTsi6jFMJxI32dZVaM/cXyVZ+0pvp0xSghgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlX0M2ZSTyKwkzKSd7pRqD8ZBH0MJl90JXXQJ9GjdYk8AAAAAAAAAAAAAAAAAAAAAAACC3+QNRwABAAAAAAAAAAAAAAAAAAAAOmcn9Iium10OjMH93G91wBtvZ5xHsfR/ZggkRxFEDKEAAAAAAAAAACBErmBD/hkxpZU25gx/AWOkxLbwC9EgS4XEeBavwj37YJnyXvYfgDK5FGNkYJgsXMbxNO8d2udmV/LL/sHr/I0Jc3QIDfb88Ny4vEsNjgr12A67/ytMWZ9U9C1jEt/DFCdgeMHMNH67vsUZi+JYUT84a5MNAsJ0moA+IzCVXr0aECDev1zqIMaRlZPtMMc3OwLsxJW3ovXW1JGSYUUHp2KgziDbVC7oNHVaoTnmGhjVn3Y5+OqpcbeorQk6AVeQMKGOazCpTT1WDICo62evBnW9j3OR1xF0QoaGfGIPYSO8XGafBYi2yAncFmmnECkfVYgHV08LdmFsaWRhdG9yLTAAAAAdL2lwNC8xMjcuMC4wLjEvdGNwLzQxNDE5L2h0dHAYL2lwNC8xMjcuMC4wLjEvdWRwLzQwMjE3GC9pcDQvMTI3LjAuMC4xL3VkcC80MTIwMxgvaXA0LzEyNy4wLjAuMS91ZHAvNDE3NjMAAAAAAAAAAN0YnGWk+SwbYVW1NFopPUKPp1j7dMXkrG8GVo3ev7STAAAAAAAAAADECQAAAAAAAPssOsxvxAfRRgFrHEQRxNjBcK/4yS/gbIFI2K+elC2XAQAAAAAAAABhuWuKHJ2yCmezW/qM5AeUeRSRq1tCdZklXxe8ZRokGQEAAAAAAAAAAAAAAILf5A1HAAAAAAAAAAAAAACC3+QNRwDmnOSG7sJwFcb9OZyoiL97YyHpCXU1aOqGK/odD2bWzQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeSTq3oK8QRpWum+23fH0lpJ8N3HV5qJrPxH+o9fA+/8AAAAAAAAAAAAAAAAAAAAAAACC3+QNRwABAAAAAAAAAAAAAAAAAAAAhZuGPM5IzEdzdsWGiXJtDk77pJmW2QQsp34WxD5SbywAAAAAAAAAAIV2TMLvM6oyu5di063FxzOsrG/BLDGvr4AtelcBU6iMYK3e75TYmMiOQNve/5HF8QX5zyx0f7byvDfsA9bJHtsuGleM9US+iwkx4l8kPVmwww2YoWzjuh1s8df1BCaZLrCtsxNLBVvoFA0ttfJfsA2D+OQiK/Af1qyTof9NedpY8iBXEzmz8g0nfMZ8gkYopLO4ndWibS0vw6bICa45p6vcJiAiSbgUO6xl/Hl7t4Cg/c6psNG4D3Ay9ZoZ2+9ySWFpTTCg+h3BWjOe96jXgSN96QoFmGPvFdbsM2n78jRiUp3pJieiPwlmtolha/984V9YxKELdmFsaWRhdG9yLTIAAAAdL2lwNC8xMjcuMC4wLjEvdGNwLzM2MzQzL2h0dHAYL2lwNC8xMjcuMC4wLjEvdWRwLzMzODA5GC9pcDQvMTI3LjAuMC4xL3VkcC80MTk0MxgvaXA0LzEyNy4wLjAuMS91ZHAvMzk5NTMAAAAAAAAAAMQ5ZO/4sBg66BH2daGqKD6XRZjvt16d3j4Dxj5RIKviAAAAAAAAAADECQAAAAAAAKf60u1lTuz8u5+exIgoUFEE1NOcnm4kalsr81jvvLsjAQAAAAAAAADVhyudSdMxhbFuc70OO3KEEM872frOhUNf4YgXGnQliQEAAAAAAAAAAAAAAILf5A1HAAAAAAAAAAAAAACC3+QNRwAwbIgPd+lhtkgfSLNV3FvFvFwVuMQirOrMQofSBCy6ygEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIeF3HOtiWFotDDeVzIdxeXh8PZdjVdIyKS8Khee8pJMAAAAAAAAAAAAAAAAAAAAAAACC3+QNRwABAAAAAAAAAAAAAAAAAAAAloHEjRx//kr2DMgOn/lh1NauEtEW3uAwg8j7Wtu+6RoAAAAAAAAAADMI6mF7t15OA1mYYr8/QuHZdjcwIb46JIyfa4ytcd2NYLP9XvtchyQDpK0T8RmVE2BtIzVKhFJJrqFXVkwj/zwVxsnmUrctdA6MrLk8vMBoaw7AzAwcdgv7QrQ2UZ/FqAVLdlM6l6nyOYfQl++WsfJSa7IHP6EKdxmUF3I0fvJ09CA4WTZLCf7Xij8UJuN7HiEprX9WCSGz40vLC6bkEm874yBtmFeg173xXO3HvbGD9anriMBJVTFYuqg3E6W8kPGSvTCHmG4Gh6AW5elcK5IsAXPI4dE2K2mr+4dbh7xIJj+L5L294x+BIgr/WM749YYPVBQLdmFsaWRhdG9yLTMAAAAdL2lwNC8xMjcuMC4wLjEvdGNwLzM5OTc1L2h0dHAYL2lwNC8xMjcuMC4wLjEvdWRwLzM4NDcxGC9pcDQvMTI3LjAuMC4xL3VkcC80NDk2NxgvaXA0LzEyNy4wLjAuMS91ZHAvMzQzOTUAAAAAAAAAAA1TL2vPLU3uzx298w6rXLdwwSW62wlA8fUjZnfoRFlwAAAAAAAAAADECQAAAAAAANnmCLbzawGGKY7uOg3TpkzDDjgf/8vgNiEdN/CGS2vrAQAAAAAAAADQU9W09ZMZSdLR1HGrSL3OW01BKwU/SJcOHmXgMeiEUgEAAAAAAAAAAAAAAILf5A1HAAAAAAAAAAAAAACC3+QNRwDHRGC9SZRsvXrx1dgYMV5yksEYkCM18r8BU2K9RLnm7AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzwILgj9go36EPdoc1we6K9Kb8YQRAn7ZJvA76/fYi9YAAAAAAAAAAAAAAAAAAAAAAACC3+QNRwABAAAAAAAAAAAAAAAAAAAAr5/1OeFJIr9R30vfFph31tk9DgW/agvM0bp0CCpzQ4IAAAAAAAAAAM0S7p98jj7SnNlN3HUOQvNotpqwkDCgztY3JbQeNb4kAAAAAAAAAAAAnUh1hNPnFRu/LdM136x23spEaAtGRd3TOy428+rdgjwEAAAAAAAAAGM4jxryljEa5hLfEPRGHEm4ye+xzYhmWYO7lKVKNW1dAAAAAAAAAAAnA91owUlXjUVkXAiVfZVL6skhY8iSw++IDnbjbzEgiwAAAAAAAAAAAEXh7PyWkJDZ0GL0QWAiY9UNFA4tpQiwhr4O6XFMZvDSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFwmBQAAAAAAAAAAAAAAAJYAAAAAAAAAAABDT9eUagAAAILf5A1HAACAoadrSjUABwAAAAAAAABNzc9bOCK6etRpSAUlBdODMaADuelHnJaVad6T1iHHHAAAAAAAAAAAAQAAAAAAAAAAAADgC3HrqokAAAAAAAAAAACAxqR+jQMAHgAAAAAAAAAQJ0KuWN+zw6B9uSbsBiLIUg5nDFTL8X3eO0yC9Bpmg651AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFQv5RhwEAAG4p/08TLbg/67J16NDwDk5mxVdIa0nGlF+OwBv0h0drAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgRjb2luDENvaW5NZXRhZGF0YQEHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDc3VpA1NVSQABAAAAAAAAAAAra5naM+9y/eRuDaN14tV1r0atgLHwC1CnPBRVGj+Y9icJA1N1aQNTVUkAAAMAAAEBAAAAAAAAAAAoa+OaNmXKdlKMENjiSfz7t8kko3q0DuQUiOKdog0A/8sAAENP15RqAAD++lq4hnqP6k6WvKEZPtNy1ae9jPAKjfMjAr55YH6QPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wVUG9vbFRva2VuRXhjaGFuZ2VSYXRlAAAAAAAAAAAAADh422Xy3cMY+hHJ7xjIyUrFeINn7vKGpbLjgwXQtF3nZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEwbIgPd+lhtkgfSLNV3FvFvFwVuMQirOrMQofSBCy6ygAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wVUG9vbFRva2VuRXhjaGFuZ2VSYXRlAAAAAAAAAAAAADh7fJXJh7P3jZ6DVeIRmGknEDC7RIVtCrs4G6gZcFYNxgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHHRGC9SZRsvXrx1dgYMV5yksEYkCM18r8BU2K9RLnm7AAAAQEAAAAAAAAAACiTLyBtvAc8U/a/xu6F58644MGBRGWR/h32H7fMPhlhigAAQ0/XlGoAAELPXcLJNzq6qoQ8BzQvIt2jPEW1zEtXXiMCZ53XfV9xAAABAQAAAAAAAAAAKJmW1Rq45mtmfvIjxDfy/PRiwO4kDRO1tGMK4aFSfbbZAABDT9eUagAAmQEejQyRGgeeU4GTtj4k2t74m1GzF4IXmERjSQl0vbwAAAEBAAAAAAAAAAAomt8N21SnxiPMh7ROLTmS9mILZA231OV9746FHccJFVYAAENP15RqAACZAR6NDJEaB55TgZO2PiTa3vibUbMXgheYRGNJCXS9vAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wVUG9vbFRva2VuRXhjaGFuZ2VSYXRlAAAAAAAAAAAAADijRbsqPemSETlQxtpks5z1sAithRrMAQ4O9CHSLMLaXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHmnOSG7sJwFcb9OZyoiL97YyHpCXU1aOqGK/odD2bWzQAAAQEAAAAAAAAAACikxkr1MEWocjPzwzdlG2gpyhOjwljP/SxMIcVaEVbHvQAAQ0/XlGoAAM5N7/6eit3JwfjRhF3OO7gTNEhDWeoJpY84qXzRkfDrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX2NhcB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwAAEAAAAAAAAAAECn+tLtZU7s/LufnsSIKFBRBNTTnJ5uJGpbK/NY77y7I4V2TMLvM6oyu5di063FxzOsrG/BLDGvr4AtelcBU6iMAIV2TMLvM6oyu5di063FxzOsrG/BLDGvr4AtelcBU6iMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAICBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbBVQb29sVG9rZW5FeGNoYW5nZVJhdGUAAAAAAAAAAAAAOLA0x6z31yMijBkmvt9ZjFjCnONuw2phvcuLyIN+cpROAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYFJILY5HCFOyLqMUwnEjfZ1lVoz9xfJVn7Sm+nTFKCGAAABAQAAAAAAAAAAKLaNwRd5c1oIP35RzQjdQnifCDZW8ThXwfPNb1mgOHkyAABDT9eUagAA68juP0BRnHnjpNigD0gZVFLf/PS/a/ADA+EXLVygUPYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZvYmplY3QCSUQABAAAAAAAAAAAAGC3gldclj6Kbhrndu1Lts6iUmW/B4BQl+J9EzJSA+WhQWG5a4ocnbIKZ7Nb+ozkB5R5FJGrW0J1mSVfF7xlGiQZIESuYEP+GTGllTbmDH8BY6TEtvAL0SBLhcR4Fq/CPfsBnUh1hNPnFRu/LdM136x23spEaAtGRd3TOy428+rdgjwAAAEBAAAAAAAAAAAou1i7p+qSpA1E/CpJqief7F5spI8FVvD+oqpQpQhB+HwAAENP15RqAADOTe/+nordycH40YRdzju4EzRIQ1nqCaWPOKl80ZHw6wAAAQEAAAAAAAAAACi9AeeI1TOLa2hFlbsO944HRc49dgQs6f2hNS4VA8b3RQAAQ0/XlGoAAOvI7j9AUZx546TYoA9IGVRS3/z0v2vwAwPhFy1coFD2AAABAQAAAAAAAAAAKL6V48lgAxaXqQiOVs7sScMd3d0GBLQiBfzCX3YLodFDAABDT9eUagAAzk3v/p6K3cnB+NGEXc47uBM0SENZ6gmljzipfNGR8OsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgZvYmplY3QCSUQABAAAAAAAAAAAAGDBxVUewOo5f1VZ8/btJYi75lPNZags5S+MDNmyihkBl9BT1bT1kxlJ0tHUcatIvc5bTUErBT9Ilw4eZeAx6IRSMwjqYXu3Xk4DWZhivz9C4dl2NzAhvjokjJ9rjK1x3Y0BnUh1hNPnFRu/LdM136x23spEaAtGRd3TOy428+rdgjwAAAEBAAAAAAAAAAAow30G/l7op4L/UtLwEw3td+sFP1schO25wzb8y7wR5cUAAENP15RqAACZAR6NDJEaB55TgZO2PiTa3vibUbMXgheYRGNJCXS9vAAAAQEAAAAAAAAAACjXqXLI9dTOmtL7Ul+UEgt1avZl4hFPb98iLhIUO8sDWgAAQ0/XlGoAAP76WriGeo/qTpa8oRk+03LVp72M8AqN8yMCvnlgfpA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMNdmFsaWRhdG9yX2NhcB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwAAEAAAAAAAAAAEDZ5gi282sBhimO7joN06ZMww44H//L4DYhHTfwhktr6zMI6mF7t15OA1mYYr8/QuHZdjcwIb46JIyfa4ytcd2NADMI6mF7t15OA1mYYr8/QuHZdjcwIb46JIyfa4ytcd2NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGb2JqZWN0AklEAAQAAAAAAAAAAABg3hR50VtESehA0BwPjDW1mN9AEdbKqM7hBeWLLRotqlvVhyudSdMxhbFuc70OO3KEEM872frOhUNf4YgXGnQliYV2TMLvM6oyu5di063FxzOsrG/BLDGvr4AtelcBU6iMAZ1IdYTT5xUbvy3TNd+sdt7KRGgLRkXd0zsuNvPq3YI8AAABAQAAAAAAAAAAKOoe2pI+WotqnmsQ2iWzo5t/mGauROxmMFrYpEfpdxFLAABDT9eUagAAmQEejQyRGgeeU4GTtj4k2t74m1GzF4IXmERjSQl0vbwAAAIAAAAAAAAAAABQ9O5TN3MDeqD1jT776tgGtwkvvDp7hNqXsU4EuEDJs9FhuWuKHJ2yCmezW/qM5AeUeRSRq1tCdZklXxe8ZRokGQAAAAAAAAAAAACC3+QNRwAAIESuYEP+GTGllTbmDH8BY6TEtvAL0SBLhcR4Fq/CPfsAAAEBAAAAAAAAAAAo92RqpWeT//rZjfQWaTX+lsnR4zuZ1WjdciI6giIBAo0AAENP15RqAACZAR6NDJEaB55TgZO2PiTa3vibUbMXgheYRGNJCXS9vAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9jYXAfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAABAAAAAAAAAABA+yw6zG/EB9FGAWscRBHE2MFwr/jJL+BsgUjYr56ULZcgRK5gQ/4ZMaWVNuYMfwFjpMS28AvRIEuFxHgWr8I9+wAgRK5gQ/4ZMaWVNuYMfwFjpMS28AvRIEuFxHgWr8I9+wAAAgAAAAAAAAAAAFD9BEItVbZ8yUw08T9OyhZiZVFOS7O/Orb069/pC86aFz8CNNvXmcfsRm2TPzYDK0CkT0dfsziqDkYpmOTnEsMZAAAAAAAAAAAAAILf5A1HAADPRByVW5lk1lCsBsDxWO5kI/HreBP/9pSwsGjcHsT7NQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAWEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAAAAAAAACDiJrmiIhgPrDeOC9CCuMR1Q4wu6llgGLO6CohOAPSUGAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEAAAAAAAAAIPVW1OMXSvL7Cx3fdabKHU2HsdNqTLc9aOnpnIfpeoc+AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAQAAAAAAAAAgw6+a9Fpv9apTE/1vK0HhFtYv3RR7n7NnSdyN7COSjhYDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUBAAAAAAAAACBnSSm04Uugd28+gpMzKh/R+6TuFGSBDGzMQRLQMFuOngIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAQAAAAAAAAAgFXdcltIAURMDdtCrNKE4ocU4m0tjiXG+hK/gGukU8GICAQAAAAAAAAAGF8WrkpMHdKDvZPt0hny7/+y3L0xGJ6z8vhor8oo7ugEAAAAAAAAAIMiFHfnbU2MWHD9ymD3QErFIQKju8+R75mmAHSbO1g+pAOvI7j9AUZx546TYoA9IGVRS3/z0v2vwAwPhFy1coFD2CW/+CUtATqdE44JtVHM/G0pIvlMDB/xvW+ue2JSklagBAAAAAAAAACDcoWb4kAUpDvZEagkpKXeLXPQR7J+KIK2DsADxGDeYmQDPRByVW5lk1lCsBsDxWO5kI/HreBP/9pSwsGjcHsT7NQwgZJxfTJjVUAk9k1u5Ae2JMZekhnN834TMDpde4I3IAQAAAAAAAAAg2c89Ju0+9nHqTSoS0YBA0pFmq9UlMG0xHKWuxEC+sXUAMwjqYXu3Xk4DWZhivz9C4dl2NzAhvjokjJ9rjK1x3Y0Rxpbj2GTO2GdKEi0SgZFwFRFPIcTf2+jjvqslrcs00AEAAAAAAAAAINwq/eJfXAWmqlotwSscu4u3xStWAAR64M0O3Qqp84zCAP76WriGeo/qTpa8oRk+03LVp72M8AqN8yMCvnlgfpA8GmJGXGBSO3ZhB5t3B3FmWD5yPZPhpgpvnLUz7hZqAsgBAAAAAAAAACDu6X1kivp5cdfeRIWEPv4/li9ka6Ye3TM/j9Yr896GLADryO4/QFGceeOk2KAPSBlUUt/89L9r8AMD4RctXKBQ9iDlVVYrjhF4GDR9pV7MJ98e7cecD0begVWoD7TjcVscAQAAAAAAAAAgi+HSPyEDAi4PZ1uLyQervnejWDg4y3xMph097cOb0JQA68juP0BRnHnjpNigD0gZVFLf/PS/a/ADA+EXLVygUPYhLwmXiQPhXJgKz/CK6gg7xTI3jNIl/3dk8pDBJ5v08QEAAAAAAAAAIDdGrE4asFIk86gWsp5N2/+b/h9RvD3ZrSU7xYsrtoXDAM5N7/6eit3JwfjRhF3OO7gTNEhDWeoJpY84qXzRkfDrLfGnH6q9VtvVk4wuepr6edui3P5ZKEBDeNWhSs3NMgEBAAAAAAAAACDincoPMv9DKttXnUYzIzOfQjHYWTTbAL23VX3Z55/x7AD++lq4hnqP6k6WvKEZPtNy1ae9jPAKjfMjAr55YH6QPC7Zg4MjpIWYDGnzwQC8f9HRyVJbOyOKgl/kDlMZN+5uAQAAAAAAAAAgnf/Bogr797qsUUd6INLRSiP0Si2kZOpECvs0Dn8k/1wAQs9dwsk3OrqqhDwHNC8i3aM8RbXMS1deIwJnndd9X3FARgSGkRd2yD2KJHWIn2TPLsZCdE0YuTm6Q0b+R4lLkgEAAAAAAAAAIPe36EQ3KuYLc/b5qbIEaWlS2a/AA5p76kEfjfRaFwdCAM5N7/6eit3JwfjRhF3OO7gTNEhDWeoJpY84qXzRkfDrSts1Qxx7/XutyC6NM8ucW6eMixAzRz3wmrl9ho4i1OcBAAAAAAAAACBdJlL1RcYA88X1V91kSB0sva9yJ2oI8KciecwXuWwseQD++lq4hnqP6k6WvKEZPtNy1ae9jPAKjfMjAr55YH6QPEy2fh22I50BIs0W6gDUE8z3iUrygMk9CA92B1VWtBQlAQAAAAAAAAAg1cVcQihmSacBCk2p4/MOyYW8BmRDjWAfBjHtUJA2CpoAQs9dwsk3OrqqhDwHNC8i3aM8RbXMS1deIwJnndd9X3FRtvfQE+ZTbDkfcUw+PiFVLl6mUABS3j452mwmUij0CAEAAAAAAAAAIMGpMwOjgTanlucj0DrF9MxkwIVei4oXutpobqM+W03uAELPXcLJNzq6qoQ8BzQvIt2jPEW1zEtXXiMCZ53XfV9xVHpuzzewIJZfpbPDI1cYfG38aYgCbotCBD2pVa0ho5EBAAAAAAAAACDQEwDU1YLmZ14ZaDFp7xb0+1fZeLYrzRO/HBVyqvD9sgBCz13CyTc6uqqEPAc0LyLdozxFtcxLV14jAmed131fcVUwJM4SdVTEkHEyYB8ugN/XxU7RS//N8GOGei/0rQNeAQAAAAAAAAAgO1ephguEX/gXEzumAivKC+4zROMOINrd6Q2HlgwhzQ0AhXZMwu8zqjK7l2LTrcXHM6ysb8EsMa+vgC16VwFTqIxqXoGk7yFzHZLVZ7++XlqsTSc9Tn2fhVnTLcvhLU+65wEAAAAAAAAAIGkD98eZi7ZdzOzXyIRGuU0azF/ts7XKkgyLN2b4CdvVAZ1IdYTT5xUbvy3TNd+sdt7KRGgLRkXd0zsuNvPq3YI8avKit8pgv3YXSt/T6cSVf46Td1lgMYL5tGx/bF8ZxtIBAAAAAAAAACDM5egofGKytAgPk7f6H9Y7AtqC+oW9eppGmKcwR0jHTQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABWuZ2jPvcv3kbg2jdeLVda9GrYCx8AtQpzwUVRo/mPYnAQAAAAAAAAAgK6zixyB/XRIC8TM2JkPBKDUlCAsETeptgP7702YCHRADa+OaNmXKdlKMENjiSfz7t8kko3q0DuQUiOKdog0A/8sBAAAAAAAAACAFYqs+6EOxWKU6FvhGmQUKlgvw3mqwmb1NsKfy8hAGEwD++lq4hnqP6k6WvKEZPtNy1ae9jPAKjfMjAr55YH6QPHjbZfLdwxj6EcnvGMjJSsV4g2fu8oalsuODBdC0XedkAQAAAAAAAAAgNqnlD8/+cHza42+Q+2Gjfc0qZPXcIps4OEGx1zCEmjABMGyID3fpYbZIH0izVdxbxbxcFbjEIqzqzEKH0gQsusp7fJXJh7P3jZ6DVeIRmGknEDC7RIVtCrs4G6gZcFYNxgEAAAAAAAAAIN/LZFWHw0JkoXxf9SRAx+71v/Vr0ALiTh8tsdIjDMKqAcdEYL1JlGy9evHV2BgxXnKSwRiQIzXyvwFTYr1Euebsky8gbbwHPFP2v8buhefOuODBgURlkf4d9h+3zD4ZYYoBAAAAAAAAACA09FdFL/QKir2i2KIh8T6lh0YHq5ZqEd8hB2WlHXn85ABCz13CyTc6uqqEPAc0LyLdozxFtcxLV14jAmed131fcZmW1Rq45mtmfvIjxDfy/PRiwO4kDRO1tGMK4aFSfbbZAQAAAAAAAAAgPVEN4h+gr6+/hgEH6yU/6BSbFHrDQiQecwijhDKkU1QAmQEejQyRGgeeU4GTtj4k2t74m1GzF4IXmERjSQl0vbya3w3bVKfGI8yHtE4tOZL2YgtkDbfU5X3vjoUdxwkVVgEAAAAAAAAAIJ3lOLFmgkNN7FNa6Ix9ke2dY5N6nPpmpfofI8Em6c5PAJkBHo0MkRoHnlOBk7Y+JNre+JtRsxeCF5hEY0kJdL28o0W7Kj3pkhE5UMbaZLOc9bAIrYUazAEODvQh0izC2lwBAAAAAAAAACBwKlrV8iF1ChfKWcexIe71BdZELRDA+cCr4MgtmWmIzQHmnOSG7sJwFcb9OZyoiL97YyHpCXU1aOqGK/odD2bWzaTGSvUwRahyM/PDN2UbaCnKE6PCWM/9LEwhxVoRVse9AQAAAAAAAAAgKfbRUMqtln/3jF8gIFTKrtfrNppinHp9b84ssE45FyIAzk3v/p6K3cnB+NGEXc47uBM0SENZ6gmljzipfNGR8Oun+tLtZU7s/LufnsSIKFBRBNTTnJ5uJGpbK/NY77y7IwEAAAAAAAAAIJte3iKoa6F0mOc5vZmgKQno0FAKFo9F8UAoJJbqEbgNAIV2TMLvM6oyu5di063FxzOsrG/BLDGvr4AtelcBU6iMsDTHrPfXIyKMGSa+31mMWMKc427DamG9y4vIg35ylE4BAAAAAAAAACBCN6LL0+0oHWs6oqL+6tNwC43M2lLHCQEX56HsG81UCAGBSSC2ORwhTsi6jFMJxI32dZVaM/cXyVZ+0pvp0xSghraNwRd5c1oIP35RzQjdQnifCDZW8ThXwfPNb1mgOHkyAQAAAAAAAAAg9ARByksvP1/PWmKhfh0i+Vasu+bkODhYdTMUS6Ae20wA68juP0BRnHnjpNigD0gZVFLf/PS/a/ADA+EXLVygUPa3gldclj6Kbhrndu1Lts6iUmW/B4BQl+J9EzJSA+WhQQEAAAAAAAAAIHPQWhgxkXKyRoXf82cKW7uZJW9KBhAvNzSTWysxOCP8AZ1IdYTT5xUbvy3TNd+sdt7KRGgLRkXd0zsuNvPq3YI8u1i7p+qSpA1E/CpJqief7F5spI8FVvD+oqpQpQhB+HwBAAAAAAAAACCqwMvFJaEud1SVvcvMLLjXAwIFEUDg8YiR19z+7OkVBADOTe/+nordycH40YRdzju4EzRIQ1nqCaWPOKl80ZHw670B54jVM4traEWVuw73jgdFzj12BCzp/aE1LhUDxvdFAQAAAAAAAAAgrNDBkr5r8G5AXaszdeA5FxHJrSNyYksTkkwaiwNCjWgA68juP0BRnHnjpNigD0gZVFLf/PS/a/ADA+EXLVygUPa+lePJYAMWl6kIjlbO7EnDHd3dBgS0IgX8wl92C6HRQwEAAAAAAAAAIKtDffKGsbpCNx2eGNi/ZqZtSZJRO5Z+Vu800XxTzzF9AM5N7/6eit3JwfjRhF3OO7gTNEhDWeoJpY84qXzRkfDrwcVVHsDqOX9VWfP27SWIu+ZTzWWoLOUvjAzZsooZAZcBAAAAAAAAACC+lsCvJLx0KJZTyUL79VRbWJr7G3aWWJY75JwSQvHNnQGdSHWE0+cVG78t0zXfrHbeykRoC0ZF3dM7Ljbz6t2CPMN9Bv5e6KeC/1LS8BMN7XfrBT9bHITtucM2/Mu8EeXFAQAAAAAAAAAgJPLaOesHRxqfWUP6jEWFfp+NUjz2sVXizR+WBq9TqGkAmQEejQyRGgeeU4GTtj4k2t74m1GzF4IXmERjSQl0vbzXqXLI9dTOmtL7Ul+UEgt1avZl4hFPb98iLhIUO8sDWgEAAAAAAAAAINw7JOaHcakzSqR8ii3Z13JkIyoGTSXbvD3h/auSX+vYAP76WriGeo/qTpa8oRk+03LVp72M8AqN8yMCvnlgfpA82eYItvNrAYYpju46DdOmTMMOOB//y+A2IR038IZLa+sBAAAAAAAAACA/BFMk8AQ49cGi0RtEHI2gZAK3Thvqsn6hfbK6/DiwLAAzCOphe7deTgNZmGK/P0Lh2XY3MCG+OiSMn2uMrXHdjd4UedFbREnoQNAcD4w1tZjfQBHWyqjO4QXliy0aLapbAQAAAAAAAAAgWZFTJWQGYUdxHCWQkjdOHWq1K/imOCApW7jymUyEGSYBnUh1hNPnFRu/LdM136x23spEaAtGRd3TOy428+rdgjzqHtqSPlqLap5rENols6Obf5hmrkTsZjBa2KRH6XcRSwEAAAAAAAAAIErba0V2TDCkfvbDLg0+gwqcoc3Olhzz4dAYEw49iNYLAJkBHo0MkRoHnlOBk7Y+JNre+JtRsxeCF5hEY0kJdL289O5TN3MDeqD1jT776tgGtwkvvDp7hNqXsU4EuEDJs9EBAAAAAAAAACA9EFICPbCOXhM2IvKvwqaEqQQps4eA1/Ex1ACzP8vEiAAgRK5gQ/4ZMaWVNuYMfwFjpMS28AvRIEuFxHgWr8I9+/dkaqVnk//62Y30Fmk1/pbJ0eM7mdVo3XIiOoIiAQKNAQAAAAAAAAAgN7Cwpof/iunRQrHboVo/avsn8Km40XrAd3tYO1b52q0AmQEejQyRGgeeU4GTtj4k2t74m1GzF4IXmERjSQl0vbz7LDrMb8QH0UYBaxxEEcTYwXCv+Mkv4GyBSNivnpQtlwEAAAAAAAAAIK/kyyUuWUszyG16x+/95Q0aTmidWNUxIC5Ad/0NsTW4ACBErmBD/hkxpZU25gx/AWOkxLbwC9EgS4XEeBavwj37/QRCLVW2fMlMNPE/TsoWYmVRTkuzvzq29Ovf6QvOmhcBAAAAAAAAACCwLiLquv0yoankLNWwUi6xIkEmFylNzrhq436C17L61ADPRByVW5lk1lCsBsDxWO5kI/HreBP/9pSwsGjcHsT7NQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBAAAAAAAAAAsDYmNzXKEc6wsGAAAABgEAAgMCBgUIBwcPDQgcIAw8BAAAAAEAAQEAAQYJAAEKAgNiY3MIdG9fYnl0ZXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQABAgAABGhhc2hqoRzrCwYAAAAGAQACAwIKBQwDBw8XCCYgDEYIAAAAAQAAAAACAAAAAQoCBGhhc2gIc2hhMl8yNTYIc2hhM18yNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQABAgABAQIAAAVhc2NpaZcGoRzrCwYAAAALAQAEAgQOAxJUBGYIBW47B6kByAEI8QIgBpEDCgqbAwsMpgO6Ag3gBQQABQAQAAIHAAAABwABAQcBAAAACAABAAAUAgMAABUCBAAAAwUGAAASBwgAABEJAQAADgUKAAAEBQsAAAoDAgAABgEAAAANAAYAAAsABgABCQ0OAQABDAwGAQABDwgNAQABEw4NAQANAwwDDgMPAwECAQgBAQoCAQgAAQsCAQgAAQYIAAEBAgcIAAgBAAEHCAABAwEGCgIBBgsCAQkAAQsCAQkAAQkAAgMDBENoYXIGT3B0aW9uBlN0cmluZxhhbGxfY2hhcmFjdGVyc19wcmludGFibGUIYXNfYnl0ZXMFYXNjaWkEYnl0ZQVieXRlcwRjaGFyDGRlc3Ryb3lfc29tZQppbnRvX2J5dGVzEWlzX3ByaW50YWJsZV9jaGFyB2lzX3NvbWUNaXNfdmFsaWRfY2hhcgZsZW5ndGgEbm9uZQZvcHRpb24IcG9wX2NoYXIJcHVzaF9jaGFyBHNvbWUGc3RyaW5nCnRyeV9zdHJpbmcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAABAAAAAAAAAgEHCgIBAgEGAgABAAAICQoAEQoEBAUGBwAnCwASAQIBAQAABAwLABECDAEOATgABAcFCQcAJwsBOAECAgEAAA8eDgBBAAwCBgAAAAAAAAAADAEoCgEKAiMEGQULDgAKAUIAFBEKIAQUOAICCwEGAQAAAAAAAAAWDAEFBSgLABIAOAMCAwEAAA8gCgAQAEEADAIGAAAAAAAAAAAMASgKAQoCIwQdBQwKABAACgFCABQRCyAEGAsAAQkCCwEGAQAAAAAAAAAWDAEFBigIAgQBAAAIBwsADwAOARABFEQAAgUBAAAIBQsADwBFABIBAgYBAAAIBAsAEQdBAAIHAQAACAMLABAAAggBAAAIAwsAEwACCQEAAAgDCwATAQIKAQAACAQLADF/JQILAQAABg0KADEgJgQJCwAxfiUMAQULCQwBCwECAAABAAAFZGVidWd0oRzrCwYAAAAGAQACAwILBQ0FBxIeCDAgDFAIAAAAAQABAQAAAgEBAAEGCQAABWRlYnVnBXByaW50EXByaW50X3N0YWNrX3RyYWNlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQIAAQECAAAGb3B0aW9u8QihHOsLBgAAAA0BAAQCBAYDCngEggEOBZABhwEHlwLbAQjyAyAGkgQUCqYEBwutBAIMrwSABA2vCAIOsQgCAA8AFgAABwEAAAAOAAEBAAARAgEBAAAMAwQBAAANAwQBAAAEBQQBAAABAwYBAAADBQYBAAAKBwIBAwAJCAABAAAICQIBAAACCQoBAAASCAIBAAATCAEBAAAHCwIBAgAGAQIBAAAFAQABAAAUAQwBAAEEDgQBAAELDQQBAAEQAgwBABMCEgIRAgMCAAIBAgICAAELAAEJAAEJAAEGCwABCQABAQIGCwABCQAGCQABBgkAAgYLAAEJAAkAAgcLAAEJAAkAAQcLAAEJAAEHCQACCwABCQAJAAEKCQABBgoJAAIGCgkABgkAAgYJAAYKCQACCQAGCgkAAQcKCQACCQAHCgkAAwsAAQkACwABCQAHCgkAAgkACgkABk9wdGlvbgZib3Jyb3cKYm9ycm93X211dBNib3Jyb3dfd2l0aF9kZWZhdWx0CGNvbnRhaW5zDGRlc3Ryb3lfbm9uZQxkZXN0cm95X3NvbWUUZGVzdHJveV93aXRoX2RlZmF1bHQHZXh0cmFjdARmaWxsEGdldF93aXRoX2RlZmF1bHQIaXNfZW1wdHkHaXNfbm9uZQdpc19zb21lBG5vbmUGb3B0aW9uCXNpbmdsZXRvbgRzb21lBHN3YXAMc3dhcF9vcl9maWxsBnRvX3ZlYwN2ZWMGdmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAABAAAAAAAAwgBAAQAAAAAAAACARUKCQAAAgABAAAAA0ACAAAAAAAAAAA5AAIBAQAAAAQLADgAOQACAgEAAAAECwA3ADgBAgMBAAAABQsANwA4ASACBAEAAAAFCwA3AAsBOAICBQEAAAANCgA4AwQEBQgLAAEHAScLADcABgAAAAAAAAAAQgICBgEAAA8TCwA3AAwDCgM4AQQLCwMBCwEMAgURCwEBCwMGAAAAAAAAAABCAgwCCwICBwEAABASCwA3AAwDCgM4AQQLCwMBCwEMAgUQCwMGAAAAAAAAAABCAhQMAgsCAggBAAAREAsANgAMAgoCLjgBBAgFDAsCAQcAJwsCCwFEAgIJAQAAAA0KAC44AwQFBQkLAAEHAScLADYARQICCgEAAAAOCgAuOAMEBQUJCwABBwEnCwA2AAYAAAAAAAAAAEMCAgsBAAASFAoALjgDBAUFCQsAAQcBJwsANgAMAwoDRQIMAgsDCwFEAgsCAgwBAAATFQsANgAMBAoELjgBBAo4BAwCBQ4KBEUCOAUMAgsCDAMLBAsBRAILAwINAQAAFA8LADoADAMNAy44AQQKCwEMAgUNDQNFAgwCCwICDgEAABQQDgA4AwQEBQYHAScLADoADAINAkUCDAELAkYCAAAAAAAAAAALAQIPAQAAAAoOADgGBAQFBgcAJwsAOgBGAgAAAAAAAAAAAhABAAAAAwsAOgACAAAAAgAGc3RyaW5n+QehHOsLBgAAAAsBAAgCCA4DFnIEiAEIBZABeweLAvgBCIMEIAajBBQKtwQGDL0EhQMNwgcCABMABAARABgAAQcAAQEHAAIABwEAAAAXAAEAAAYCAQAAFQECAAAWAAMAAAUEBQAADgQGAAAPBAcAAAIICQAAAwoJAAAICwkAABQMAQAABw0HAAAJBQYAAAsOBgAADA8AAAAKEAcAAQ0CAAABEwACAAIQCRIBAAISERIBAAMCFQkBAAMOFAYBABMBEgEVExQTAQoCAQgAAQgBAQsCAQgAAQYIAAEGCgIBAQEDAgcIAAgAAAIHCAAKAgMHCAADCAADBggAAwMCBggABggAAgYKAgMDBgoCAwMCBgoCBgoCAQkAAQsCAQkAAQIBBgoJAAIHCgkACgkACAEDAwMGCgIIAAgAAwUBAQEGCgIDBk9wdGlvbgZTdHJpbmcGYXBwZW5kC2FwcGVuZF91dGY4BWFzY2lpBWJ5dGVzCmZyb21fYXNjaWkIaW5kZXhfb2YGaW5zZXJ0E2ludGVybmFsX2NoZWNrX3V0ZjgRaW50ZXJuYWxfaW5kZXhfb2YZaW50ZXJuYWxfaXNfY2hhcl9ib3VuZGFyeRNpbnRlcm5hbF9zdWJfc3RyaW5nCmludG9fYnl0ZXMIaXNfZW1wdHkGbGVuZ3RoBG5vbmUGb3B0aW9uBHNvbWUGc3RyaW5nCnN1Yl9zdHJpbmcIdG9fYXNjaWkIdHJ5X3V0ZjgEdXRmOAZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAQAAAAAAAAADCAIAAAAAAAAAAAIBBQoCAAEAAAkJDgARDAQEBQYHACcLABIAAgEBAAAJBAsAERASAAICAQAACQQLABMAERECAwEAAAMMDgARDAQICwASADgADAEFCjgBDAELAQIEAQAACQMLABAAAgUBAAAJBAsAEAA4AgIGAQAACQQLABAAQRMCBwEAAAkHCwAPAA4BEAAUOAMCCAEAAAkFCwALAREAEQcCCQEAABY4CgAQAAwHCgEKB0ETJQQNCwcKARENDAMFEQsHAQkMAwsDBBQFGAsAAQcBJwoALhEGDAoKAAoBDAQuBgAAAAAAAAAACwQRCgwJCgALAQsKDAYMBS4LBQsGEQoMCA0JCwIRBw0JCwgRBwsJCwAVAgoBAAAXMAsAEAAMBgoGQRMMBwoCCwclBA8KAQoCJQwDBREJDAMLAwQYCgYKARENDAQFGgkMBAsEBCEKBgoCEQ0MBQUjCQwFCwUEJgUqCwYBBwEnCwYLAQsCEQ4SAAILAQAACQYLABAACwEQABEPAgwAAgANAAIADgACAA8AAgAAAAAGdmVjdG9ykQihHOsLBgAAAAgBAAIDAmYEaAQFbGEHzQGaAQjnAiAGhwMKDJED2AQAEQAFAAEBAAAJAgMBAAABBAUBAAALBgABAAACBwgBAAAKCQoBAAAEAQABAAAPCwABAAAOCgEBAAANCQABAAAADAABAAAIAg0BAAADDg0BAAAGDg8BAAAMBwoBAAAHEAABAAAQBwoBAAkKCwoAAQoJAAEGCgkAAQMCBgoJAAMBBgkAAgcKCQAJAAIHCgkAAwEHCQABBwoJAAEJAAMHCgkAAwMCBwoJAAoJAAEBAgYKCQAGCQACAQMDBwoJAAkAAwMDAwMCAwMDAwcKCQADBmFwcGVuZAZib3Jyb3cKYm9ycm93X211dAhjb250YWlucw1kZXN0cm95X2VtcHR5BWVtcHR5CGluZGV4X29mBmluc2VydAhpc19lbXB0eQZsZW5ndGgIcG9wX2JhY2sJcHVzaF9iYWNrBnJlbW92ZQdyZXZlcnNlCXNpbmdsZXRvbgRzd2FwC3N3YXBfcmVtb3ZlBnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAIAAAAAAAABAgABAQIAAgECAAMBAgAEAQIABQECAAYBAgAHAQIACAEAAAEHQAoAAAAAAAAAAAwBDQELAEQKCwECCQEAABEmCgAuQQoMAwoDBgAAAAAAAAAAIQQLCwABAgYAAAAAAAAAAAwCCwMGAQAAAAAAAAAXDAEKAgoBIwQjBRYKAAoCCgFHCgsCBgEAAAAAAAAAFgwCCwEGAQAAAAAAAAAXDAEFEQsAAQIKAQAAABENATgADgE4ASAEDAUHCgANAUUKRAoFAgsAAQsBRgoAAAAAAAAAAAILAQAAAAULAEEKBgAAAAAAAAAAIQIMAQAAEiEGAAAAAAAAAAAMAgoAQQoMAwoCCgMjBBsFCgoACgJCCgoBIQQWCwABCwEBCAILAgYBAAAAAAAAABYMAgUFCwABCwEBCQINAQAAEiMGAAAAAAAAAAAMAgoAQQoMAwoCCgMjBBwFCgoACgJCCgoBIQQXCwABCwEBCAsCAgsCBgEAAAAAAAAAFgwCBQULAAELAQEJBgAAAAAAAAAAAg4BAAATJQoALkEKDAQKAQoEJgQMCwABBwAnCwQGAQAAAAAAAAAXDAQKAQoEIwQiBRUKAAwDCgEMAgsBBgEAAAAAAAAAFgwBCwMLAgoBRwoFEAsARQoCDwEAAAMgCgAuQQoMAwoCCgMkBAwLAAEHACcKAAsBRAoKAgoDIwQdBRQKAAoCCgNHCgsCBgEAAAAAAAAAFgwCBQ8LAAECEAEAAAMXCgAuOAEgBAYFCgsAAQcAJwoALkEKBgEAAAAAAAAAFwwCCgALAQsCRwoLAEUKAgAHYWRkcmVzc2WhHOsLBgAAAAYBAAIDAgUFBwMHCg8IGSAMORAAAAABAAEAAAEDB2FkZHJlc3MGbGVuZ3RoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAQAAAAIGIAAAAAAAAAACAAl0eXBlX25hbWWMBKEc6wsGAAAACgEABgIGCAMOKQU3LAdjeQjcASAG/AEHCoMCBgyJAtMBDdwDAgANAAIABAABBwACAAcAAAYAAQEAAAUCAwAABwIEAAAIAgQAAAkBBAABCgAGAAIDAwcAAgwJBAAAAQgAAQYIAAEGCAEBCAEECgIDAwYKAgEDAQYKAgECAQoCBQIGAgMKAgYKAgZTdHJpbmcIVHlwZU5hbWUHYWRkcmVzcwhhc19ieXRlcwVhc2NpaQ1ib3Jyb3dfc3RyaW5nA2dldAtnZXRfYWRkcmVzcwpnZXRfbW9kdWxlC2ludG9fc3RyaW5nBmxlbmd0aARuYW1lBnN0cmluZwl0eXBlX25hbWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQIBOgoCAQAAAgELCAEAAQIAAQEAAAADCwAQAAICAQAABSERBQYCAAAAAAAAABgMAwsAEAARBgwEBwEMAQYAAAAAAAAAAAwCCgIKAyMEHAURDQEKBAoCQggURAgLAgYBAAAAAAAAABYMAgUMCwQBCwERBwIDAQAACicRBQYCAAAAAAAAABgGAgAAAAAAAAAWDAMLABAAEQYMBQcBDAQKBQoDQggMAgcADAEKAg4BIgQgBRcNBAsCFEQICwMGAQAAAAAAAAAWDAMFDAsFAQsCAQsEEQcCBAEAAAAEDgAQABQCAAAACmJpdF92ZWN0b3KrBqEc6wsGAAAACgEAAgICBAMGIwUpJAdNbQi6ASAG2gEoCoICCAyKAu8DDfkFBAACAAAHAAAGAAEAAAcCAwAACQIDAAAIAgMAAAMEBQAABAYAAAAFBAAAAQMBCAACBwgAAwACBggAAwEBAQYIAAIKAQMBBwEFAwcBAwMDCUJpdFZlY3RvcgliaXRfZmllbGQKYml0X3ZlY3Rvcgxpc19pbmRleF9zZXQGbGVuZ3RoIGxvbmdlc3Rfc2V0X3NlcXVlbmNlX3N0YXJ0aW5nX2F0A25ldwNzZXQKc2hpZnRfbGVmdAV1bnNldAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAIAAAAAAAMIAQACAAAAAAADCAEAAAAAAAAAAwgABAAAAAAAAAACAgQDAQoBAAEAAAclCgAGAAAAAAAAAAAkBAUFBwcBJwoABwMjBAwFDgcBJwYAAAAAAAAAAAwCQAUAAAAAAAAAAAwBKAoCCgAjBCAFGA0BCUQFCwIGAQAAAAAAAAAWDAIFEigLAAsBEgACAQEAAAgUCgEKABAAQQUjBAcFCwsAAQcAJwsADwALAUMFDAIICwIVAgIBAAAIFAoBCgAQAEEFIwQHBQsLAAEHACcLAA8ACwFDBQwCCQsCFQIDAQAACVkKAQoAEAEUJgQhCgAQAEEFDAYGAAAAAAAAAAAMBAoECgYjBB4FEQoADwAKBEMFDAMJCwMVCwQGAQAAAAAAAAAWDAQFDAsAAQVYCgEMBQoFCgAQARQjBEEFKgoACgUMAi4LAhEEBDcKAAoFCgEXEQEFPAoACgUKARcRAgsFBgEAAAAAAAAAFgwFBSMKABABFAsBFwwFCgUKABABFCMEVgVOCgAKBRECCwUGAQAAAAAAAAAWDAUFRwsAAQIEAQAAAxEKAQoAEABBBSMEBwULCwABBwAnCwAQAAsBQgUUAgUBAAADBAsAEABBBQIGAQAAACUKAQoAEAEUIwQHBQsLAAEHACcKAQwCCgIKABABFCMEIQUUCgAKAhEEIAQcCwABBSELAgYBAAAAAAAAABYMAgUNCwILARcCAAEAAAANZml4ZWRfcG9pbnQzMtYEoRzrCwYAAAAKAQACAgIEAwYeBSQWBzp6CLQBIAbUAUQKmAIFDJ0CiQINpgQCAAQAAAcAAAcAAQAAAwABAAABAgMAAAIBAwAABQMBAAAGAwQAAgMIAAEDAgMDAQgAAQEBBAQBBAQEAAxGaXhlZFBvaW50MzIUY3JlYXRlX2Zyb21fcmF0aW9uYWwVY3JlYXRlX2Zyb21fcmF3X3ZhbHVlCmRpdmlkZV91NjQNZml4ZWRfcG9pbnQzMg1nZXRfcmF3X3ZhbHVlB2lzX3plcm8MbXVsdGlwbHlfdTY0BXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEEP//////////AAAAAAAAAAADCAEAAQAAAAAAAwgCAAIAAAAAAAMIAwACAAAAAAADCAQAAQAAAAAAAwgFAAIAAAAAAAACAQgDAAEAAAUUCwA1DgEQABQ1GDEgMAwCCgIHACUEDwURBwMnCwI0AgEBAAAFHQ4BEAAUBgAAAAAAAAAAIgQHBQkHBCcLADUxIC8OARAAFDUaDAIKAgcAJQQYBRoHAicLAjQCAgEAAAYwCgA1MUAvDAULATUxIC8MBAoEMgAAAAAAAAAAAAAAAAAAAAAiBA8FEQcBJwsFCwQaDAMKAzIAAAAAAAAAAAAAAAAAAAAAIgQcCAwCBSALAAYAAAAAAAAAACEMAgsCBCMFJQcFJwoDBwAlBCoFLAcFJwsDNBIAAgMBAAAHAwsAEgACBAEAAAcEDgAQABQCBQEAAAcGDgAQABQGAAAAAAAAAAAhAgAAAAcNZml4ZWRfcG9pbnQzMgxGaXhlZFBvaW50MzIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQZvcHRpb24GT3B0aW9uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEFYXNjaWkGU3RyaW5nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEFYXNjaWkEQ2hhcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCmJpdF92ZWN0b3IJQml0VmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEGc3RyaW5nBlN0cmluZwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABCXR5cGVfbmFtZQhUeXBlTmFtZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAMgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEAAAAAAAAAKQNiYWfsBaEc6wsGAAAACwEACAIIDAMUcASEAQwFkAFSB+IBuQEImwMgBrsDCgrFAwgMzQPmAQ2zBQQABAALABIAFQAADAACAgQAAwECAAARAAEAAAMCAwIHBAAFBAUCBwQABgYHAgcEABMGCAIHBAAHBAkBBwAIBAkCBwQAEAoLAAAPCgkAAAoBAwABAw4DAgcEAQUPBQIHBAEGEAcCBwQBDA8JAQcBDQ8JAgcEARMQCAIHBAIJDAMAAhEADAAKDQsNDA0PDQ0RDg0BBwgCAQgAAwcIAAkACQEAAgYIAAkAAQYJAQIHCAAJAAEHCQEBCQEBAQEGCAABAwEIAQIJAAkBAwcIAQkACQECBggBCQACBwgBCQABCQACCAEDA0JhZwlUeENvbnRleHQDVUlEA2FkZANiYWcGYm9ycm93CmJvcnJvd19tdXQIY29udGFpbnMSY29udGFpbnNfd2l0aF90eXBlBmRlbGV0ZQ1kZXN0cm95X2VtcHR5DWR5bmFtaWNfZmllbGQHZXhpc3RzXxBleGlzdHNfd2l0aF90eXBlAmlkCGlzX2VtcHR5Bmxlbmd0aANuZXcGb2JqZWN0BnJlbW92ZQRzaXplCnR4X2NvbnRleHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAAAAgIOCAEUAwABAAADBQsAEREGAAAAAAAAAAASAAIBAQAAAw4KAA8ACwELAjgACgAQARQGAQAAAAAAAAAWCwAPARUCAgEAAAMFCwAQAAsBOAECAwEAAAMFCwAPAAsBOAICBAEAAAgPCgAPAAsBOAMMAgoAEAEUBgEAAAAAAAAAFwsADwEVCwICBQEAAAMFCwAQAAsBOAQCBgEAAAMFCwAQAAsBOAUCBwEAAAMECwAQARQCCAEAAAMGCwAQARQGAAAAAAAAAAAhAgkBAAASDgsAEwAMAgwBCwIGAAAAAAAAAAAhBAkFCwcAJwsBERACAAAAAQADYmNzlQ+hHOsLBgAAAAsBAAoCCgoDFIcBBJsBGAWzAYMBB7YC3gIIlAVABtQFNwqLBgYMkQbLCA3cDgIAAwEDAQoBHwACAAAHAAIBBwEAAAAeAAEBAAAIAQIAAAYCAQAACwMEAAAMAwUAABQDBgAAEwMHAAASAwgAABcDBwAAFQMJAAAWAwoAABoDAQAAGwMLAAAZAwwAABgDDQAADQMOAAAOAw8AABEDEAAAEAMRAAAPAxIAAR4AAQEAAgkTIQEAAh0UIQEAAxwVEwEABAUBBAAEBxMHABQUFwYWBBUEFgUVBRYGFQYWBxUHFggVCAEGCQABCgIBCAABBwgAAQUBAQECAQMBBAEKBQEKAQEKCgIBCgMBCgQBCwEBBQELAQEBAQsBAQIBCwEBAwELAQEEAAEJAAEHCgkAAgoCAwIBAgMDAgMDBAIEBAMDAgMDAwMKBQMDAwoBAwMDCgIDAwMKCgIDAwMKAwMDAwoEAQsBAQkAA0JDUwZPcHRpb24HYWRkcmVzcwNiY3MFYnl0ZXMKZnJvbV9ieXRlcxRpbnRvX3JlbWFpbmRlcl9ieXRlcwZsZW5ndGgDbmV3BG5vbmUGb3B0aW9uDHBlZWxfYWRkcmVzcwlwZWVsX2Jvb2wTcGVlbF9vcHRpb25fYWRkcmVzcxBwZWVsX29wdGlvbl9ib29sEHBlZWxfb3B0aW9uX3UxMjgPcGVlbF9vcHRpb25fdTY0DnBlZWxfb3B0aW9uX3U4CXBlZWxfdTEyOAhwZWVsX3U2NAdwZWVsX3U4EHBlZWxfdmVjX2FkZHJlc3MNcGVlbF92ZWNfYm9vbA9wZWVsX3ZlY19sZW5ndGgNcGVlbF92ZWNfdTEyOAxwZWVsX3ZlY191NjQLcGVlbF92ZWNfdTgPcGVlbF92ZWNfdmVjX3U4B3JldmVyc2UEc29tZQh0b19ieXRlcwZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAACgUBAAoBAQAKAgEACgoCAQAKAwEACgQBAAACAQQKAgABAAATAwsAOAACAQEAABMFDQA4AQsAEgACAgEAAAEHCwATAAwBDQE4AQsBAgMBAAAWIwoAEABBBhEZJgQHBQsLAAEHACdABgAAAAAAAAAABgAAAAAAAAAADAIMAQoCERkjBB4FFA0BCgAPAEUGRAYLAgYBAAAAAAAAABYMAgUPCwABCwERGAIEAQAAFxULABEFDAIKAjEAIQQKCQwBBRMLAjEBIQQPBREHAScIDAELAQIFAQAAEw8KABAAQQYGAQAAAAAAAAAmBAcFCwsAAQcAJwsADwBFBgIGAQAAGCgKABAAQQYGCAAAAAAAAAAmBAcFCwsAAQcAJwYAAAAAAAAAADEADAIMAwoCMUAjBCQFFAoADwBFBjQMAQsDCwEKAi8WDAMLAjEIFgwCBQ8LAAELAwIHAQAAGSgKABAAQQYGEAAAAAAAAAAmBAcFCwsAAQcAJzIAAAAAAAAAAAAAAAAAAAAAMQAMAgwDCgIxgCMEJAUUCgAPAEUGNQwBCwMLAQoCLxYMAwsCMQgWDAIFDwsAAQsDAggBAAAaMAYAAAAAAAAAADEABgAAAAAAAAAADAIMAwwECgIGBAAAAAAAAAAlBAsFDwsAAQcCJwoADwBFBjQMAQsCBgEAAAAAAAAAFgwCCwQKAQZ/AAAAAAAAABwKAy8bDAQLAQaAAAAAAAAAABwGAAAAAAAAAAAhBCcFLAsDMQcWDAMFBgsAAQsEAgkBAAAbGQoAEQgGAAAAAAAAAAAHAwwDDAEMAgoBCgIjBBUFDA0DCgARA0QECwEGAQAAAAAAAAAWDAEFBwsAAQsDAgoBAAAcGQoAEQgGAAAAAAAAAAAHBAwDDAEMAgoBCgIjBBUFDA0DCgARBEQFCwEGAQAAAAAAAAAWDAEFBwsAAQsDAgsBAAAdGQoAEQgGAAAAAAAAAAAHBQwDDAEMAgoBCgIjBBUFDA0DCgARBUQGCwEGAQAAAAAAAAAWDAEFBwsAAQsDAgwBAAAeGQoAEQgGAAAAAAAAAAAHBgwDDAEMAgoBCgIjBBUFDA0DCgARC0QBCwEGAQAAAAAAAAAWDAEFBwsAAQsDAg0BAAAfGQoAEQgGAAAAAAAAAAAHBwwDDAEMAgoBCgIjBBUFDA0DCgARBkQHCwEGAQAAAAAAAAAWDAEFBwsAAQsDAg4BAAAgGQoAEQgGAAAAAAAAAAAHCAwDDAEMAgoBCgIjBBUFDA0DCgARB0QICwEGAQAAAAAAAAAWDAEFBwsAAQsDAg8BAAAODgoAEQQECAsAEQM4AgwBBQwLAAE4AwwBCwECEAEAAA8OCgARBAQICwARBDgEDAEFDAsAATgFDAELAQIRAQAAEA4KABEEBAgLABEFOAYMAQUMCwABOAcMAQsBAhIBAAARDgoAEQQECAsAEQY4CAwBBQwLAAE4CQwBCwECEwEAABIOCgARBAQICwARBzgKDAEFDAsAATgLDAELAQIAAAADaGV4swqhHOsLBgAAAAgBAAQDBBUEGQIFGyUHQCwIbEAGrAGfBgzLB8ICAAQBBQADAAAAAAEAAAAAAgEBAAEAAwQBAAMBAQoCAQIFCgoCBwoCAwMKAgIHCgkACgkAAAQCAwMKAgUBAQECAgZhcHBlbmQGZGVjb2RlC2RlY29kZV9ieXRlBmVuY29kZQNoZXgGdmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAACgoCggaAAgIwMAIwMQIwMgIwMwIwNAIwNQIwNgIwNwIwOAIwOQIwYQIwYgIwYwIwZAIwZQIwZgIxMAIxMQIxMgIxMwIxNAIxNQIxNgIxNwIxOAIxOQIxYQIxYgIxYwIxZAIxZQIxZgIyMAIyMQIyMgIyMwIyNAIyNQIyNgIyNwIyOAIyOQIyYQIyYgIyYwIyZAIyZQIyZgIzMAIzMQIzMgIzMwIzNAIzNQIzNgIzNwIzOAIzOQIzYQIzYgIzYwIzZAIzZQIzZgI0MAI0MQI0MgI0MwI0NAI0NQI0NgI0NwI0OAI0OQI0YQI0YgI0YwI0ZAI0ZQI0ZgI1MAI1MQI1MgI1MwI1NAI1NQI1NgI1NwI1OAI1OQI1YQI1YgI1YwI1ZAI1ZQI1ZgI2MAI2MQI2MgI2MwI2NAI2NQI2NgI2NwI2OAI2OQI2YQI2YgI2YwI2ZAI2ZQI2ZgI3MAI3MQI3MgI3MwI3NAI3NQI3NgI3NwI3OAI3OQI3YQI3YgI3YwI3ZAI3ZQI3ZgI4MAI4MQI4MgI4MwI4NAI4NQI4NgI4NwI4OAI4OQI4YQI4YgI4YwI4ZAI4ZQI4ZgI5MAI5MQI5MgI5MwI5NAI5NQI5NgI5NwI5OAI5OQI5YQI5YgI5YwI5ZAI5ZQI5ZgJhMAJhMQJhMgJhMwJhNAJhNQJhNgJhNwJhOAJhOQJhYQJhYgJhYwJhZAJhZQJhZgJiMAJiMQJiMgJiMwJiNAJiNQJiNgJiNwJiOAJiOQJiYQJiYgJiYwJiZAJiZQJiZgJjMAJjMQJjMgJjMwJjNAJjNQJjNgJjNwJjOAJjOQJjYQJjYgJjYwJjZAJjZQJjZgJkMAJkMQJkMgJkMwJkNAJkNQJkNgJkNwJkOAJkOQJkYQJkYgJkYwJkZAJkZQJkZgJlMAJlMQJlMgJlMwJlNAJlNQJlNgJlNwJlOAJlOQJlYQJlYgJlYwJlZAJlZQJlZgJmMAJmMQJmMgJmMwJmNAJmNQJmNgJmNwJmOAJmOQJmYQJmYgJmYwJmZAJmZQJmZgoCAQAAAQAAAiEGAAAAAAAAAAAHAw4AQQEMBAwFDAMKAwoEIwQfBQwNBQwCBwIMAQsCDgEOAAoDQgEUNEIAFDgACwMGAQAAAAAAAAAWDAMFBwsFAgEBAAAFLwYAAAAAAAAAAAcDDgBBAQwDDAQMAgoDBgIAAAAAAAAAGQYAAAAAAAAAACEEDgUQBwAnCgIKAyMELQUVDgAKAkIBFBECMRAYDgAKAgYBAAAAAAAAABZCARQRAhYMAQ0ECwFEAQsCBgIAAAAAAAAAFgwCBRALBAICAAAABkAxMAoAJQQJCgAxOiMMAQULCQwBCwEEEgsAMTAXDAUFPjFBCgAlBBsKADFHIwwCBR0JDAILAgQmMQoLABYxQRcMBAU8MWEKACUELwoAMWcjDAMFMQkMAwsDBDQFNgcBJzEKCwAWMWEXDAQLBAwFCwUCAANwYXnDBqEc6wsGAAAACQEACAIICgMSTQRfDgVtfgfrAa0BCJgDIAa4AwoMwgPWAgAJAAIADwAQAQAMAQABAwECAAAIAAEBAAAMAgEBAAAOAwEBAAANBAEBAAADAgEBAAAFBQEBAAAGBgEBAAAHBwEBAAEEAhABAAEFBQEBAAEMAgoBAAIKCwEBDAMLCAkACwoKDAAMAQwIDAkMBgwCCwABCQAGCAEAAwcLAAEJAAMHCAEDBwsAAQkACgMHCAEEBwsAAQkAAwUHCAECBwsAAQkACwABCQACBwsAAQkACgsAAQkAAgoLAAEJAAUBBggBAQUBCwABCQACCQAFAQkAAgMDAQMDAwMKCwABCQABCgsAAQkAAwsAAQkAAwMEQ29pbglUeENvbnRleHQEY29pbg9kaXZpZGVfYW5kX2tlZXANZGl2aWRlX2ludG9fbgRqb2luCGpvaW5fdmVjFWpvaW5fdmVjX2FuZF90cmFuc2ZlcgRrZWVwA3BheQ9wdWJsaWNfdHJhbnNmZXIGc2VuZGVyBXNwbGl0EnNwbGl0X2FuZF90cmFuc2ZlcglzcGxpdF92ZWMIdHJhbnNmZXIKdHhfY29udGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAABAAABBQsACwERDDgAAgEBBAABCAsACwEKAjgBCwIuOAICAgEEAA0bBgAAAAAAAAAADgFBDgwEDAMKAwoEIwQWBQoKAA4BCgNCDhQKAjgDCwMGAQAAAAAAAAAWDAMFBQsAAQsCAQIDAQQAAQcLAAsBCwM4AQsCOAACBAEEAA8fCwALAQoCOAQMBQYAAAAAAAAAAA4FQQoMBAwDCgMKBCMEGgUPDQVFCgoCLhEMOAALAwYBAAAAAAAAABYMAwUKCwIBCwVGCgAAAAAAAAAAAgUBBAABBAsACwE4BQIGAQQAERoGAAAAAAAAAAAOAUEKDAQMAwoDCgQjBBUFCg0BRQoMAgoACwI4BQsDBgEAAAAAAAAAFgwDBQULAAELAUYKAAAAAAAAAAACBwEEAAoSDgBBCgYAAAAAAAAAACQEBgUIBwAnDQBFCgwCDQILADgGCwILATgAAgADc3Vp2AahHOsLBgAAAAoBAA4CDjADPj4EfA4FigGFAQePAoECCJAEQAbQBGYKtgUFDLsFbQAWARIACQAKABcAGQAaAAQCAAEDBwEAAAIABAEAAQIFBAEAAQMBDAEAAQMCDAEAAQMGDAEAAQUHAgAGCAcAABAAAQAAFwIDAAERAwkBAAIMEAcBAAIPERIBAAMLCwwBAgMYDxABAAQTDgMBDAQUFAMBDAUOBQcABRUFBgACCAUKBw0GCgQKAwoIEwEHCAcBCwIBCAACCwQBCAAFAAQLBQEIAAsDAQgACwIBCAALBgEIAAEGCAcBBQEDAQgIAQsBAQkAAQgABwkAAgoCCgIKAgsBAQgIBwgHAgsGAQkACwUBCQABCwUBCAABCQABCwYBCQABCwMBCQACBwsDAQkAAwELAgEJAAELBAEIAAIJAAUHQmFsYW5jZQRDb2luDENvaW5NZXRhZGF0YQZPcHRpb24DU1VJBlN1cHBseQtUcmVhc3VyeUNhcAlUeENvbnRleHQDVXJsB2JhbGFuY2UEY29pbg9jcmVhdGVfY3VycmVuY3kOZGVzdHJveV9zdXBwbHkLZHVtbXlfZmllbGQFZXBvY2gPaW5jcmVhc2Vfc3VwcGx5A25ldwRub25lBm9wdGlvbhRwdWJsaWNfZnJlZXplX29iamVjdA9wdWJsaWNfdHJhbnNmZXIGc2VuZGVyA3N1aQh0cmFuc2ZlchR0cmVhc3VyeV9pbnRvX3N1cHBseQp0eF9jb250ZXh0A3VybAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAMqaOwAAAAADCADkC1QCAAAAAwgAAOiJBCPHigUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAgQDU1VJCgIEA1N1aQoCAQAAAgENAQAAAAAELwoALhEKBwUhBAcFCwsAAQcBJwoALhEJBgAAAAAAAAAAIQQSBRYLAAEHACcJEgAxCQcGBwcHCDgACwA4AQwBDAQLATgCCwQ4AwwCDQIHBDgEDAMLAjgFAQsDAgEBBAADBAsACwE4BgIAA3VybKoCoRzrCwYAAAAJAQAEAgQIAwwZBSUUBzlOCIcBQArHAQYMzQEyDf8BAgAIAQIAAQcAAQAHAAAEAAEAAAUCAQAAAwMAAAAHBAUAAQYCAAABCAEBCAABCgIBBggAAgcIAAgBAAZTdHJpbmcDVXJsBWFzY2lpCWlubmVyX3VybApuZXdfdW5zYWZlFW5ld191bnNhZmVfZnJvbV9ieXRlcwZzdHJpbmcGdXBkYXRlA3VybAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAgEICAEAAQAABQMLABIAAgEBAAAFBAsAEQQSAAICAQAABQQLABAAFAIDAQAABQULAQsADwAVAgAAAARjb2lugRKhHOsLBgAAAA0BABYCFj4DVJsCBO8CJAWTA+MCB/YFogUImAtABtgLHgr2CzQLqgwIDLIM9AQNphEODrQRDgAPAQsBLQEyAAwAGQAsADkAOwA8AEEAAQwBAAEAAgwBAAEABwwBAAEAAwMBAAEBBQcAAgQHAQAAAwUHAAQABAEAAQQGBAEAAQYJBAAICAIACgoHAAA4AAEBAAA6AgMBAAAzBAUBAAA0BAYBAABDBwEBAAAMBwgBAAANCQoBAAAaCwwBAAAjDA0BAAA3DgwBAAAvDxABAAAlERABAAAxEgwBAAAXEhMBAABEFAwBAAAWDBABAAAQFRYBAgAmFwwBAAAoGA0BAAAOGQEBAAAnGhABAAA/GxABAABAHBABAAA9GxABAAA+HBABAAAbHR4BAAAeHR8BAAAfHSABAAAcHR8BAAAdHSEBAAEyKiAAAjAiLwEAA0IqHwAEESIDAQIEEywBAQAEFg0QAQAEIisNAQAEJSUBAQAEMSQNAQAENQUBAQAEQwgBAQAERBANAQAFGCIQAQMGFCMQAAYqFCMABy4tEAEMCSQnKAECCisgLgAnIigiJiIIIiUiCSIEIgwiKSIjIi4iKikhIiQiIiIRIi0MHy4BBgsCAQkAAQMBCwIBCQABCwgBCQABBwsCAQkAAQYLCAEJAAEHCwgBCQABBgsAAQkAAQYLBwEJAAEHCwABCQABBwsHAQkAAgsHAQkABwgKAQsAAQkAAQsHAQkAAwcLBwEJAAMHCAoCBwsHAQkACwABCQAAAgcLAAEJAAsAAQkAAwcLAAEJAAMHCAoBCgsAAQkAAQcICgcJAAIKAgoCCgILBQEICwcICgILAgEJAAsBAQkAAwcLAgEJAAMHCAoCBwsCAQkAAwIHCwIBCQALAAEJAAQHCwIBCQADBQcICgMGCwIBCQAHCwEBCQAIBgMGCwIBCQAHCwEBCQAIBAEGCwEBCQABAgEIBgEIBAELBQEICwEJAAEICQIHCwcBCQADAgcLBwEJAAsHAQkAAwMDCgsAAQkAAQYJAAEBAQsDAQkAAQoCAgcLCAEJAAMCBwsIAQkACwcBCQACCQAFAQgLAQsFAQkAB0JhbGFuY2UEQ29pbgxDb2luTWV0YWRhdGEPQ3VycmVuY3lDcmVhdGVkBk9wdGlvbgZTdHJpbmcGU3VwcGx5C1RyZWFzdXJ5Q2FwCVR4Q29udGV4dANVSUQDVXJsBWFzY2lpB2JhbGFuY2ULYmFsYW5jZV9tdXQEYnVybgRjb2luD2NyZWF0ZV9jdXJyZW5jeQ1jcmVhdGVfc3VwcGx5CGRlY2ltYWxzD2RlY3JlYXNlX3N1cHBseQZkZWxldGULZGVzY3JpcHRpb24MZGVzdHJveV96ZXJvDWRpdmlkZV9pbnRvX24EZW1pdAVldmVudAxmcm9tX2JhbGFuY2UMZ2V0X2RlY2ltYWxzD2dldF9kZXNjcmlwdGlvbgxnZXRfaWNvbl91cmwIZ2V0X25hbWUKZ2V0X3N5bWJvbAhpY29uX3VybAJpZA9pbmNyZWFzZV9zdXBwbHkMaW50b19iYWxhbmNlE2lzX29uZV90aW1lX3dpdG5lc3MEam9pbgRtaW50EW1pbnRfYW5kX3RyYW5zZmVyDG1pbnRfYmFsYW5jZQRuYW1lA25ldwpuZXdfdW5zYWZlBm9iamVjdAZvcHRpb24PcHVibGljX3RyYW5zZmVyA3B1dARzb21lBXNwbGl0BnN0cmluZwZzdXBwbHkKc3VwcGx5X211dAxzdXBwbHlfdmFsdWUGc3ltYm9sBHRha2UMdG90YWxfc3VwcGx5CHRyYW5zZmVyFHRyZWFzdXJ5X2ludG9fc3VwcGx5CnR4X2NvbnRleHQFdHlwZXMSdXBkYXRlX2Rlc2NyaXB0aW9uD3VwZGF0ZV9pY29uX3VybAt1cGRhdGVfbmFtZQ11cGRhdGVfc3ltYm9sA3VybAR1dGY4BXZhbHVlBHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAAICIQgJDAsHAQkAAQIGIQgJEgIpCAY2CAQVCAYgCwUBCAsCAgIhCAk4CwgBCQADAgESAgIiACIDIgEiAAEAABAECwA3ADgAAgEBAAADBgsAOgAMARErCwECAgEAABADCwA3AAIDAQAAEAMLADYAAgQBAAAQBAsANwE4AQIFAQAAEAMLADcBAgYBAAAQAwsANgECBwEAABAFCwERLAsAOQECCAEAAA0GCwA6AQwBESsLAQIJAQAAEAcLAhEsCwALATgCOQECCgEAABAGCwALATgDOAQBAgsBBAANCgsBOgEMAhErCwA2AQsCOAQBAgwBAAAQBgsANgELAQsCOAUCDQEAACY7CgEGAAAAAAAAAAAkBAUFCwsAAQsCAQcBJwoBCgAuOAYlBBIFGAsAAQsCAQcCJ0AMAAAAAAAAAAAMBQYAAAAAAAAAAAwDCgAuOAYKARoMBCgKAwoBBgEAAAAAAAAAFyMENQUqDQUKAAoECgI4B0QMCwMGAQAAAAAAAAAWDAMFIgsAAQsCAQsFAg4BAAAQBQsAESw4CDkBAg8BAAANBwsAOgEMARErCwE4CQIQAQAAEBwOADgKBAQFCAsGAQcAJwoBOQI4CwoGESwLADgMOQALBhEsCwELAxEgCwIRHgsEESALBTkDAhEBAAAQCAsCESwLADYACwE4DTkBAhIBAAAQBQsANgALATgNAhMBBAANCQsBOgEMAhErCwA2AAsCOA4CFAEEABAHCwALAQsDOA8LAjgQAhUBBAAQBQsCCwE2AhUCFgEEABAFCwILATYDFQIXAQQAEAULAgsBNgQVAhgBBAAQBwsCES84EQsBNgUVAhkBAAAQBAsANwYUAhoBAAAQBAsANwIUAhsBAAAQBAsANwMUAhwBAAAQBAsANwQUAh0BAAAQBAsANwUUAgIBAAEBAgEDAQQBBQEBACIBIgIiAyIEIgUiBiIABGhhc2hxoRzrCwYAAAAGAQACAwIKBQwHBxMaCC0gDE0IAAEAAAABAAACAAEAAQYKAgEKAgpibGFrZTJiMjU2BGhhc2gJa2VjY2FrMjU2AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQIAAQECAAAEaG1hY2ShHOsLBgAAAAYBAAIDAgUFBwoHERMIJCAMRAQAAAABAAEAAgYKAgYKAgEKAgRobWFjDWhtYWNfc2hhM18yNTYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgABAgAABG1hdGinBaEc6wsGAAAABgEAAgMCIwUlEgc3OQhwIAyQAfkDAAIAAwABAAAEAAEAAAAAAQAABQIBAAAGAQEAAAcDAwAAAQABAAIDAwEDAgMCAQQDBAQEAw8PDwRkaWZmE2RpdmlkZV9hbmRfcm91bmRfdXAEbWF0aANtYXgDbWluA3BvdwRzcXJ0CXNxcnRfdTEyOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAEAAAELCgAKASQEBwsADAIFCQsBDAILAgIBAQAAAQsKAAoBIwQHCwAMAgUJCwEMAgsCAgIBAAABDwoACgEkBAkLAAsBFwwCBQ0LAQsAFwwCCwICAwEAAAEhBgEAAAAAAAAADAIKATEBJgQfBQcKATECGTEAIQQWCgALABgMAAsBMQIaDAEFHgsCCgAYDAILATEBFwwBBQILAgIEAQAABCsyAAAAAAAAAAABAAAAAAAAAAwBMgAAAAAAAAAAAAAAAAAAAAAMAgsANQwDCgEyAAAAAAAAAAAAAAAAAAAAACIEKAUMCgMKAgoBFiYEHwsDCgIKARYXDAMLAjEBMAoBFgwCBSMLAjEBMAwCCwExAjAMAQUHCwI0AgUBAAAFK0oAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAwBSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAILAE0MAwoBSgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIgQoBQwKAwoCCgEWJgQfCwMKAgoBFhcMAwsCMQEwCgEWDAIFIwsCMQEwDAILATECMAwBBQcLAjUCBgEAAAETCgAKARkGAAAAAAAAAAAhBAsLAAsBGgwCBRELAAsBGgYBAAAAAAAAABYMAgsCAgAFY2xvY2uiA6Ec6wsGAAAACwEACAIIDAMUHwQzAgU1HgdTegjNASAG7QEsCpkCCAyhAk8N8AICAAMABwALAAwAAAgAAQIEAAMBAgAACgABAAAFAgMAAAQEAwABAwMGAAIJCAMBCAMIAgUABAcBBggAAQMBBggCAAMHCAADBggCAQUBCAEBCAABCQAFQ2xvY2sJVHhDb250ZXh0A1VJRAVjbG9jaxljb25zZW5zdXNfY29tbWl0X3Byb2xvZ3VlBmNyZWF0ZQJpZAZvYmplY3QGc2VuZGVyDHNoYXJlX29iamVjdAx0aW1lc3RhbXBfbXMIdHJhbnNmZXIKdHhfY29udGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgIGCAEKAwABAAADBAsAEAAUAgEAAAADDQsAEQUHASEEBgUIBwAnEQMGAAAAAAAAAAASADgAAgIAAAADDwsCEQUHASEEBgUKCwABBwAnCwELAA8AFQIAAQAFZWN2cmaKAaEc6wsGAAAABwEAAgMCBQUHDwcWEwgpIAZJHgxnBAAAAAEAAQAEBgoCBgoCBgoCBgoCAQEFZWN2cmYMZWN2cmZfdmVyaWZ5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAAAAQIAAAVldmVudFehHOsLBgAAAAYBAAIDAgYFCAQHDAsIFyAMNwQAAQAAAAEBAwEJAAAEZW1pdAVldmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAECAAAFa2lvc2upGaEc6wsGAAAADQEAFgIWTgNkowIEhwM0BbsDuwMH9gazBgipDUAG6Q1aCsMOSAuLDwQMjw/DCQ3SGBIO5BgGACoBMwASABQAFwAYABoAMgBGAEgASQAFDAAABgwAAAoMAQwBAAMHAAAHBwAACAcAAAQDAQwBAQkHAQAAAgAEAQABAwEMAQABBwIHAAcPBAAICwIACQwMAQABCQ0AAQABCg4CAAAwAAEAABMCAwAARQQFAAA1BgUBDAAuBwUBDABHCAkBDAAsCgUBDAA2CwUBDAA7DA0BDAAtDg8BDAA/EA0BDABCEQUBDABOEgMAAB8TFAAAJRMUAAAjExQAACQTFAAAHhUUAABLFRYAAEQXBQAAShgWAAA0GRoAACcZGwAAORkcAAA6FR0AAD0eHwEMADweHwEMAD4eHAEMARY+CQEAASY9FAEAAik2HAEAAk0/HAEAAk8FIwEAAx0pKgEAAyEqIwEAA0dAKgEAA001HAEABBAsBQIHBAQbQhQBBwRAMDICBwQEQTAxAgcEBRAsBQIHDAUbQhQBBwVAMDICBwwGGQkFAQMHFSEFAAcgJh8BCAcwACEAB0woHwAJMTc4AQAKQyQaACAiLiUhIi4JKSslLQMJKC8rKyUvLDMGCScvJCIiIh4iKC0xCQgJHRwcHB8iIyIqQSZDJkQBBwgPAggACAEDCAAIAQcIDwELCQEIDAMHCAAGCAEGCA8AAwcIAAYIAQkABAcIAAYIAQYLDQEJAAkAAwcIAAYIAQgKAQkABAcIAAYIAQgKAwQHCAAGCAEJAAMDBwgACAoLCQEIDAIJAAsOAQkABQcIAAYIAQgKAwcIDwELAgEJAAMHCAALAgEJAAsJAQgMAgcIAAsCAQkABAcIAAYIAQsHAQMHCA8CBggACAoBAQIHCAAGCAEBBwgLAwcIAAYIAQEBBwgAAQYIAAEFAQ4BAwEHCwgBCAwBBgsCAQkAAQgKAggBCAABCAsBCAwBCwgBCQABBggPAQgAAQYJAAUICwgKCAsOCwgBCAwBBggLAgsIAQkABwgPAQsJAQkAAggDCQADBwgLCQAJAQIIBQECCAoICgIIBAMCBwgLCQABCwcBCQEBCQEBCwYBCQACCQADAQYLCQEJAAIHCwgBCQALCAEJAAMICgMICgELDgEJAAYICggLCAoICgMICwUICwgKCAoDAwMICwgKCAoDAwMDAQYLBwEJAAELBwEJAAEGCwgBCQADBwsIAQkAAwcIDwEIAwIGCAsJAAEIBQEIBAdCYWxhbmNlBENvaW4CSUQESXRlbQpJdGVtTGlzdGVkBUtpb3NrDUtpb3NrT3duZXJDYXAHTGlzdGluZwRMb2NrBk9wdGlvbgtQdXJjaGFzZUNhcANTVUkOVHJhbnNmZXJQb2xpY3kPVHJhbnNmZXJSZXF1ZXN0CVR4Q29udGV4dANVSUQDYWRkEGFsbG93X2V4dGVuc2lvbnMHYmFsYW5jZRJjbG9zZV9hbmRfd2l0aGRyYXcEY29pbgZkZWxldGUMZGVzdHJveV9zb21lDWR5bmFtaWNfZmllbGQUZHluYW1pY19vYmplY3RfZmllbGQEZW1pdAVldmVudAdleGlzdHNfA2Zvcgxmcm9tX2JhbGFuY2UKaGFzX2FjY2VzcwhoYXNfaXRlbQJpZAxpbnRvX2JhbGFuY2UMaXNfZXhjbHVzaXZlCWlzX2xpc3RlZBVpc19saXN0ZWRfZXhjbHVzaXZlbHkJaXNfbG9ja2VkB2lzX3NvbWUKaXRlbV9jb3VudAdpdGVtX2lkBGpvaW4Fa2lvc2sIa2lvc2tfaWQEbGlzdBZsaXN0X3dpdGhfcHVyY2hhc2VfY2FwBGxvY2sJbWluX3ByaWNlA25ldwtuZXdfcmVxdWVzdAZvYmplY3QGb3B0aW9uBW93bmVyBXBsYWNlDnBsYWNlX2FuZF9saXN0BXByaWNlB3Byb2ZpdHMOcHJvZml0c19hbW91bnQLcHJvZml0c19tdXQIcHVyY2hhc2URcHVyY2hhc2VfY2FwX2l0ZW0ScHVyY2hhc2VfY2FwX2tpb3NrFnB1cmNoYXNlX2NhcF9taW5fcHJpY2URcHVyY2hhc2Vfd2l0aF9jYXAGcmVtb3ZlEHJlbW92ZV9pZl9leGlzdHMTcmV0dXJuX3B1cmNoYXNlX2NhcAZzZW5kZXIUc2V0X2FsbG93X2V4dGVuc2lvbnMJc2V0X293bmVyA3N1aQR0YWtlD3RyYW5zZmVyX3BvbGljeQp0eF9jb250ZXh0B3VpZF9tdXQQdWlkX211dF9hc19vd25lcgx1aWRfdG9faW5uZXIFdmFsdWUId2l0aGRyYXcEemVybwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAMIBQAAAAAAAAADCAYAAAAAAAAAAwgHAAAAAAAAAAMICAAAAAAAAAAAAgUgCAs4CwgBCAw0BScOEQEBAgIgCAscCAoCAgQgCAsrCAooCAovAwMCASAICgQCAiAICiIBBQIBIAgKBgIDKggKIAgKNwMGCQIJAAEAACATCgARLzgACgAuETJJAAAAAAgSAAwCCwARLw4COAESAQwBCwILAQIBAQAAJyYLABMAAQwGAQwHDAULARMBDAQMAw4FETALBCEEEQUVCwIBBwAnCwZJAAAAACEEGgUeCwIBBwMnCwMRLQsFES0LBwsCOAICAgEAAAUVCgAuOAELARAAFCEECQUPCwABCwIBBwAnCwIRMgsADwEVAgMBAAAFHQoALjgBCwEQABQhBAkFDQsAAQcAJwoAEAIUSQEAAAAWCgAPAhULAA8DDgI4AxIDCwI4BAIEAQAABQwKAA8DDgM4AxIFCDgFCwALAQsDOAYCBQEAAC48CgAuOAELARAAFCEECQUNCwABBwAnCgAKAgwDLgsDEQ4gBBYFGgsAAQcIJwoACgIMBC4LBBEQIAQjBScLAAEHBCcKABACFEkBAAAAFwoADwIVCgAPAwoCCRIEOAcBCwAPAwsCEgM4CAIGAQAAHykKAC44AQsBEAAUIQQJBQ0LAAEHACcKAAoCDAQuCwQRECAEFgUaCwABBwQnCgAPAwoCCRIECgM4CQsALjgBCwILAzkAOAoCBwEAAB8NDgI4AwwECgAKAQsCOAYLAAsBCwQLAzgLAggBAAA0MwoADwMKAQkSBDgMDAQKAA8DCgESAzgIDAMKABACFEkBAAAAFwoADwIVCgQOAjgNIQQbBR8LAAEHAScKAA8ECwI4DjgPAQoADwMKARIFOBABCwMLAQsECwAuOAE4EQIJAQAAOTwKAC44AQoBEAAUIQQJBRELAAELBAELAQEHACcKAAoCDAUuCwURDyAEGgUiCwABCwQBCwEBBwYnCwQRLwwKCwAPAwoCCBIECgM4CQsKDAYLAgwHCwEQABQMCAsDDAkLBgsICwcLCTkBAgoBAAA6MgsBOgEMBgwEDAUMAw4COA0MBwoHCwYmBA4FEgsAAQcBJwoALjgBCwUhBBkFHQsAAQcFJwoADwMKBAgSBDgMAQoADwMKBAkSBAsHOAkLAxEtCwALBAsCOBICCwEAADsbCwE6AQEMAwwEDAIKAC44AQsEIQQNBRELAAEHBScLAA8DCwMIEgQ4DAELAhEtAgwBAAA8MQoALjgBCwEQABQhBAkFDwsAAQsDAQcAJw4COBMEJQsCOBQMBgoGCgAQBDgVJQQcBSILAAELAwEHAicLBgwEBSkKABAEOBUMBAsEDAULAA8ECwULAzgWAg0BAAAFBgsAEAMLARIDOBcCDgEAAAUGCwAQAwsBEgU4GAIPAQAAFBIKABADCgEJEgQ4GQQMCwABCAwCBRALAAsBERAMAgsCAhABAAAFBwsAEAMLAQgSBDgZAhEBAAAFCAsALjgBCwEQABQhAhIBAAAFEAoALjgBCwEQABQhBAkFDQsAAQcAJwsADwMCEwEAAAUSCgAuOAELARAAFCEECQUNCwABBwAnCwILAA8FFQIUAQAABQwKABAFFAQFBQkLAAEHBycLAA8DAhUBAAAFBAsAEAEUAhYBAAAFBAsAEAIUAhcBAAAFBAsAEAQ4FQIYAQAABRAKAC44AQsBEAAUIQQJBQ0LAAEHACcLAA8EAhkBAAAFBAsANwAUAhoBAAAFBAsANwEUAhsBAAAFBAsANwIUAgEBAAIAAwAAAAEABAIBAgICAwYJBwkICQAFdGFibGWCBqEc6wsGAAAADQEACAIIEAMYcwSLAQoFlQFoB/0BpwEIpAMgBsQDCgrOAwgL1gMCDNgD5QENvQUEDsEFBAATAAoAEAAUAAAMAgcBBAECAgQAAwECAAAPAAECBwQAAwIDAgcEAAQEBQIHBAAFBgcCBwQAEQYIAgcEAAYECQIHBAAOCgsCBwQADQoJAgcEAAgBAwIHBAAJAQMCBwYBAw4DAgcEAQQPBQIHBAEFEAcCBwQBCw8JAgcEAREQCAIHBAIHDAMAAg8ADAAKDQsNDA0ODQ0NAQcIAgELAAIJAAkBAwcLAAIJAAkBCQAJAQACBgsAAgkACQEJAAEGCQECBwsAAgkACQEJAAEHCQEBCQEBAQEGCwACCQAJAQEDAQgBAgkACQEDBwgBCQAJAQIGCAEJAAIHCAEJAAIIAQMFVGFibGUJVHhDb250ZXh0A1VJRANhZGQGYm9ycm93CmJvcnJvd19tdXQIY29udGFpbnMGZGVsZXRlDWRlc3Ryb3lfZW1wdHkEZHJvcA1keW5hbWljX2ZpZWxkEGV4aXN0c193aXRoX3R5cGUCaWQIaXNfZW1wdHkGbGVuZ3RoA25ldwZvYmplY3QGcmVtb3ZlBHNpemUFdGFibGUKdHhfY29udGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAACAgwIARIDAA0AAQAAAwULABEQBgAAAAAAAAAAOQACAQEAAAMOCgA2AAsBCwI4AAoANwEUBgEAAAAAAAAAFgsANgEVAgIBAAADBQsANwALATgBAgMBAAADBQsANgALATgCAgQBAAAIDwoANgALATgDDAIKADcBFAYBAAAAAAAAABcLADYBFQsCAgUBAAADBQsANwALATgEAgYBAAADBAsANwEUAgcBAAADBgsANwEUBgAAAAAAAAAAIQIIAQAAEQ4LADoADAIMAQsCBgAAAAAAAAAAIQQJBQsHACcLAREPAgkBAAADBQsAOgABEQ8CAAAAAQANAQ0ABXR5cGVzaKEc6wsGAAAABgEAAgMCBgUIBgcOGggoIAxIBAABAAAAAQECAQYJAAEBE2lzX29uZV90aW1lX3dpdG5lc3MFdHlwZXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgABAgAABmJvcnJvd/4EoRzrCwYAAAANAQAIAggYAyA7BFsKBWVTB7gBngEI1gJABpYDFAqqAxMLvQMCDL8DfQ28BAQOwAQEAAUBDwAOABMAAwQBDAAAAAAAAQIHAQAAAgEHAAMEAgAADAABAQwABQIDAQwAEAQFAQwABgEGAQwBBwkGAQABCAsGAQABCQ8FAQABEgYJAQACCwwNAQgDCgcIAAcGBQYIBgYGBAYCCQAHCAQBCwABCQABBwsAAQkAAgkACAEDBwsAAQkACQAIAQABCQABBwgEAQUBCwIBCQACCAMJAAEHCwIBCQABBgkAAQgDAggDBQIHCwIBCQAJAAZCb3Jyb3cCSUQGT3B0aW9uCFJlZmVyZW50CVR4Q29udGV4dAZib3Jyb3cHZGVzdHJveQxkZXN0cm95X3NvbWUHZXh0cmFjdARmaWxsFGZyZXNoX29iamVjdF9hZGRyZXNzAmlkA25ldwNvYmoGb2JqZWN0Bm9wdGlvbghwdXRfYmFjawNyZWYEc29tZQp0eF9jb250ZXh0BXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAAICCwUUCwIBCQABAgIRBQ0IAwAGAAEAAAUGCwERCQsAOAA5AAIBAQAACg4KADYAOAEMAg4COAIMAQsCCwA3ARQLARIBAgIBAAAOHgsCEwEMAwwEDgE4AgsDIQQKBQ4LAAEHAScKADcBFAsEIQQVBRkLAAEHACcLADYACwE4AwIDAQAACQcLADoADAEBCwE4BAIAAQAAAAYBBgAGb2JqZWN0twihHOsLBgAAAAwBAAgCCAwDFH4EkgEGBZgBIwe7AfoCCLUEQAb1BHAK5QULDPAFggIN8gcED/YHCAAYAQQAAwAeAAAHAAACBAADAQIAABUAAQAAFAACAAATAQMAABICAwAAGwQFAAAIBgUAAB8HAAAAIgcDAAAhBwEAACAHAgAAFggFAAAJBQYAAA8JAwEIAAUJAAEIABEJAQEIABAJAgEIAAYJBwEIABcCBQAACgIGAAAZAgYAARwJAQEAAg4BAgADDQgCAAMaBAIAFAIQChQDAQYIAAEKAgEFAQgAAQYIAgEIAQABBggBAQcIAgEGCQABCQACSUQJVHhDb250ZXh0A1VJRAdhZGRyZXNzA2Jjcwlib3Jyb3dfaWQKYm9ycm93X3VpZAVieXRlcwVjbG9jawZkZWxldGULZGVsZXRlX2ltcGwNZHluYW1pY19maWVsZBRkeW5hbWljX29iamVjdF9maWVsZBRmcmVzaF9vYmplY3RfYWRkcmVzcwpmcm9tX2J5dGVzAmlkCmlkX2FkZHJlc3MIaWRfYnl0ZXMPaWRfZnJvbV9hZGRyZXNzDWlkX2Zyb21fYnl0ZXMNaWRfdG9fYWRkcmVzcwtpZF90b19ieXRlcwNuZXcRbmV3X3VpZF9mcm9tX2hhc2gGb2JqZWN0DnJlY29yZF9uZXdfdWlkBnNlbmRlchBzdWlfc3lzdGVtX3N0YXRlCHRvX2J5dGVzCHRyYW5zZmVyCnR4X2NvbnRleHQMdWlkX2FzX2lubmVyDnVpZF90b19hZGRyZXNzDHVpZF90b19ieXRlcwx1aWRfdG9faW5uZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYDCAAAAAAAAAAABSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAQcFAQIBDwgAAAEAAAYECwAQADgAAgEBAAAGBAsAEAAUAgIBAAAGBAsAERURAwIDAQAABgMLABIAAgQAAAAGDAsAERcHAyEEBgUIBwInBwASABIBAgUDAAAGBAcBEgASAQIGAQAABgMLABABAgcBAAAGBAsAEAEUAggBAAAGBQsAEAEQADgAAgkBAAAGBQsAEAEQABQCCgEAAAYFCwARFhIAEgECCwEAAAYFCwATARMAERICDAEAAAYFCwA4ARABFAINAQAABgQLADgBEAECDgEAAAYFCwA4ARABOAICDwEAAAYGCwA4ARABEAAUAhAAAgARAwAABgYKABETCwASABIBAhIAAgATAAIAAAABAAAIAAsADAAdAAZwcm92ZXJdoRzrCwYAAAAEAQACBwIHCAkgBikeAAAGcHJvdmVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAAAB2FkZHJlc3PKA6Ec6wsGAAAACQEACgIKCAMSPQRPAgVRFAdlgQEI5gFABqYCNgzcAkUAAQECAQMBCwAIAQAHAAMABwAADwABAAAHAQAAAAYCAAAADQACAAAMAAMAAA4ABAAACQUGAAAKBQEAAQsCAwACDQcCAQADBQMEAAQEAgIACQABBQEPAQoCAQgAAQgBAAEDAQYJAAZTdHJpbmcHYWRkcmVzcwVhc2NpaQNiY3MGZW5jb2RlCmZyb21fYXNjaWkKZnJvbV9ieXRlcwlmcm9tX3UyNTYDaGV4Bmxlbmd0aANtYXgGc3RyaW5nD3RvX2FzY2lpX3N0cmluZwh0b19ieXRlcwl0b19zdHJpbmcHdG9fdTI1NgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCCAAAAAAAAAADyD//////////////////////////////////////////wMIAAAAAAAAAAAAAQIAAQECAAIBAgADAQAABQMOADgAAgQBAAAFBQsAEQMRCxEIAgUBAAAFBAsAEQQRCgIGAQAABQIHAAIHAQAABQIHAQIAB2JhbGFuY2XIB6Ec6wsGAAAADgEABAIEEAMUUwRnAgVpYwfMAeABCKwDIAbMA0oKlgQKC6AEBAykBNsCDf8GBA6DBwQPhwcCAAMAEAABBAEAAQAABAEAAQECAgAAEQABAQAADwIBAQAABQMEAQIACgUGAQAABgcBAQAAEwgGAQAACwkBAQAADQoGAQAAEgsGAQAACQYIAQAABAwGAQAABw0IAQAACAQBAQABDA4PAAcDAQYLAQEJAAEDAQYLAAEJAAEJAAELAAEJAAIHCwABCQADAQsBAQkAAgcLAAEJAAsBAQkAAAIHCwEBCQALAQEJAAIHCwEBCQADAQcLAQEJAAIDBggCAgsBAQkABggCAQYIAgEFB0JhbGFuY2UGU3VwcGx5CVR4Q29udGV4dAdiYWxhbmNlFmNyZWF0ZV9zdGFraW5nX3Jld2FyZHMNY3JlYXRlX3N1cHBseQ9kZWNyZWFzZV9zdXBwbHkXZGVzdHJveV9zdG9yYWdlX3JlYmF0ZXMOZGVzdHJveV9zdXBwbHkMZGVzdHJveV96ZXJvD2luY3JlYXNlX3N1cHBseQRqb2luBnNlbmRlcgVzcGxpdANzdWkMc3VwcGx5X3ZhbHVlCnR4X2NvbnRleHQFdmFsdWUMd2l0aGRyYXdfYWxsBHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAAFIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBEQMBAgERAwADAQMAAQAACAQLADcAFAIBAQAACAQLADcBFAICAQAACAMGAAAAAAAAAAA5AAIDAQAACBgKAQb//////////woANwEUFyMECQUNCwABBwEnCgA3ARQKARYLADYBFQsBOQECBAEAAAEYCwE6AQwCCgA3ARQKAiYECgUOCwABBwEnCgA3ARQKAhcLADYBFQsCAgUBAAAIAwYAAAAAAAAAADkBAgYBAAABDwsBOgEMAgoANwAUCwIWCgA2ABULADcAFAIHAQAACBYKADcAFAoBJgQHBQsLAAEHAicKADcAFAoBFwsANgAVCwE5AQIIAQAAAQgKADcAFAwBCwALATgAAgkBAAAIDQ4ANwAUBgAAAAAAAAAAIQQHBQkHACcLADoBAQIKAAAACAsLARENBwQhBAYFCAcDJwsAOQECCwAAAAgMCwERDQcEIQQGBQgHAycLADoBAQIMAwAACAMLADoAAgEAAAAAAwEDAA4AB2Rpc3BsYXnmCqEc6wsGAAAADQEAEAIQLgM+hAEEwgEWBdgBxAEHnAPfAgj7BUAGuwYUCs8GJgv1BgYM+wagAw2bCgYOoQoGAA4BHwASABoAGwAgACEAJAAADAEIAQABAwEIAQAIAwEIAQEEBwADAgcAAwYEAAQDDAAGBQIABwcHAgEAAAAAGAABAQgAGQIBAQgADAADAQgAIwQDAQgACQUDAQgACwYDAQgADwUDAQgAHQcDAQgAFwgJAQgAJQoLAQgAEwoMAQgADQ0BAQgACgUDAQgCEA4DAQMDGA0cAAMiFRYABBQICQEABRwTAwEMBh4REgAHEQMeAgEABxYfAwIBAAcdGhsCAQAIDgsOAA4MDhEBDRcVGRAODR0TGRQZAgYIBgcIBwELAAEJAAQGCAYKCAMKCAMHCAcAAQcLAAEJAAMHCwABCQAIAwgDAwcLAAEJAAoIAwoIAwIHCwABCQAIAwEGCAYBAQEGCwABCQABDQEGCwgCCAMIAwEHCAcBCQADCwABCQADAwEIAwEGCAcBBQIJAAUCDQsIAggDCAMBBggFAQgEAQsCAQkAAgMDAggDCAMCBwsIAgkACQEGCQACCQAJAQEIBQELAQEJAAELCAIJAAkBAwcLCAIJAAkBCQAJAQdEaXNwbGF5DkRpc3BsYXlDcmVhdGVkAklECVB1Ymxpc2hlcgZTdHJpbmcJVHhDb250ZXh0A1VJRAZWZWNNYXAOVmVyc2lvblVwZGF0ZWQDYWRkDGFkZF9pbnRlcm5hbAxhZGRfbXVsdGlwbGUPY3JlYXRlX2FuZF9rZWVwD2NyZWF0ZV9pbnRlcm5hbAdkaXNwbGF5BGVkaXQEZW1pdAVlbXB0eQVldmVudAZmaWVsZHMMZnJvbV9wYWNrYWdlAmlkBmluc2VydA1pc19hdXRob3JpemVkA25ldw9uZXdfd2l0aF9maWVsZHMGb2JqZWN0B3BhY2thZ2UPcHVibGljX3RyYW5zZmVyBnJlbW92ZQZzZW5kZXIGc3RyaW5nCHRyYW5zZmVyCnR4X2NvbnRleHQMdWlkX3RvX2lubmVyDnVwZGF0ZV92ZXJzaW9uB3ZlY19tYXAHdmVyc2lvbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAACAxUIBRMLCAIIAwgDJQ0BAgEVCAQCAgMVCAQlDRMLCAIIAwgDAg4BDgAOAAEAAAMLCwA4AAQEBQgLAQEHACcLATgBAgEBAAAPKw4BQRAMBgoGDgJBECEECQUPCwABCwMBBwEnBgAAAAAAAAAADAULAAsDOAIMBAoFCgYjBCkFGg0EDgEKBUIQFA4CCgVCEBQ4AwsFBgEAAAAAAAAAFgwFBRULBAICAQQAAwgLAAoBOAILAS4REjgEAgMBBAAUGAoANwAUSAEAFgoANgAVCgA3ABQMAQoANwEUDAILADcCEQ8LAQsCOQA4BQIEAQQAAwULAAsBCwI4AwIFAQQAGCYOAUEQDAQKBA4CQRAhBAkFDQsAAQcBJwYAAAAAAAAAAAwDCgMKBCMEIwUUCgAOAQoDQhAUDgIKA0IQFDgDCwMGAQAAAAAAAAAWDAMFDwsAAQIGAQQAAwsKADYBDgE4BgEBCwALAQsCOAMCBwEEAAMHCwA2AQ4BOAYBAQIIAQAAAwMLADgHAgkBAAADBAsANwAUAgoBAAADAwsANwECCwAAABwMCwARDgwBDgERDzkBOAgLATgJSAAAOQICDAAAAAMGCwA2AQsBCwI4CgIAAgABAAAADgEOAg4AB2VkMjU1MTlqoRzrCwYAAAAGAQACAwIFBQcMBxMXCCogDEoEAAAAAQABAAMGCgIGCgIGCgIBAQdlZDI1NTE5DmVkMjU1MTlfdmVyaWZ5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQIAAAdncm90aDE2zQahHOsLBgAAAAoBAAICAhADEjIFREwHkAHtAgj9AyAGnQQeCrsEIAzbBLQBDY8GDgAKAAAHAAABBwAAAwcAAAIHAAAFAAEAAAYAAQAAEAIDAAARAwQAAA8FBgAADgUHAAAMCAMAAA0JAwAAEgoLAAATDAsAAAEIAAQKAgoCCgIKAgEIAQEKCgIBCgIBCAIBCAMCBggABgoCAgIGCgIEBggABggBBggCBggDAQEHAgYKAgYKAgYKAgYKAgYKAgYKAgVDdXJ2ZRRQcmVwYXJlZFZlcmlmeWluZ0tleQtQcm9vZlBvaW50cxFQdWJsaWNQcm9vZklucHV0cxZhbHBoYV9nMV9iZXRhX2cyX2J5dGVzCGJsczEyMzgxBWJuMjU0BWJ5dGVzFWRlbHRhX2cyX25lZ19wY19ieXRlcxVnYW1tYV9nMl9uZWdfcGNfYnl0ZXMHZ3JvdGgxNgJpZBVwcmVwYXJlX3ZlcmlmeWluZ19rZXkecHJlcGFyZV92ZXJpZnlpbmdfa2V5X2ludGVybmFsF3Byb29mX3BvaW50c19mcm9tX2J5dGVzHnB1YmxpY19wcm9vZl9pbnB1dHNfZnJvbV9ieXRlcw5wdmtfZnJvbV9ieXRlcwxwdmtfdG9fYnl0ZXMUdmVyaWZ5X2dyb3RoMTZfcHJvb2YddmVyaWZ5X2dyb3RoMTZfcHJvb2ZfaW50ZXJuYWwVdmtfZ2FtbWFfYWJjX2cxX2J5dGVzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAAAAgELAgECBBQKAgQKAgkKAggKAgICAQcKAgMCAQcKAgABAAAAAzEAEgACAQEAAAADMQESAAICAQAAAAYLAAsBCwILAxIBAgMBAAAEGEAFAAAAAAAAAAAMAQ0BDgAQABREBQ0BDgAQARREBQ0BDgAQAhREBQ0BDgAQAxREBQsBAgQBAAAAAwsAEgICBQEAAAADCwASAwIGAQAAAAYLABAEFAsBEQcCBwACAAgBAAAAEQsAEAQUCgEQAAoBEAEKARACCwEQAwsCEAULAxAGEQkCCQACAAEAAQEBAgEDAAACAAMAAAdwYWNrYWdl/w2hHOsLBgAAAAsBAA4CDiQDMrcBBOkBCgXzAXYH6QL+BAjnB0AGpwhdCoQJMAy0CYEEDbUNFAAkAQoBMgAhADAAMQAzAAEMAAAGDAAACAAAAAcAAAECBwACBAcAAwAHAAMFBAAFAwIAAA4AAQECAA8AAgECAAwBAgAAFgMEAQAAFQMEAQAAJwMFAAAoAwUAADQGBwAANgYIAAA1BgkAAC4KBwAALwoJAAApCwcAACoLBwAALQoMAAARAgkAAAkCCQAAEwIJAAAiDQIAACMNAgAAHg4CAAALDxAAABARAgAAKxICAAIXAhMBAAIYGBkAAhkYGQADEhcCAAMaFQcBCAMbGwcAAxwfGwADIBYXAAQmHAIBDAUsGhsABh0VBAECIhQYFAAUIAEcDgIJAAcICAEIAAABBggAAQEBBggEAQYIAQEIBgEDAQIBBggCAQYIAwEGCgIBBwgBAQgBAwcIAQIKAgEIAgIHCAEIAwIHCAECAQgFAQkAAQYJAAEHCAgBCAcBBggFAQgEAQYICAEFAgkABQIBCAUCCAYIBgEGCAYCSUQJUHVibGlzaGVyBlN0cmluZwlUeENvbnRleHQIVHlwZU5hbWUDVUlEClVwZ3JhZGVDYXAOVXBncmFkZVJlY2VpcHQNVXBncmFkZVRpY2tldA9hZGRpdGl2ZV9wb2xpY3kFYXNjaWkRYXV0aG9yaXplX3VwZ3JhZGUOYnVybl9wdWJsaXNoZXIDY2FwBWNsYWltDmNsYWltX2FuZF9rZWVwDmNvbW1pdF91cGdyYWRlEWNvbXBhdGlibGVfcG9saWN5BmRlbGV0ZQ9kZXBfb25seV9wb2xpY3kGZGlnZXN0C2Zyb21fbW9kdWxlDGZyb21fcGFja2FnZQNnZXQLZ2V0X2FkZHJlc3MKZ2V0X21vZHVsZQJpZA9pZF9mcm9tX2FkZHJlc3MNaWRfdG9fYWRkcmVzcxNpc19vbmVfdGltZV93aXRuZXNzDm1ha2VfaW1tdXRhYmxlC21vZHVsZV9uYW1lA25ldwZvYmplY3QWb25seV9hZGRpdGl2ZV91cGdyYWRlcxFvbmx5X2RlcF91cGdyYWRlcwdwYWNrYWdlBnBvbGljeQ9wdWJsaWNfdHJhbnNmZXIQcHVibGlzaGVkX21vZHVsZRFwdWJsaXNoZWRfcGFja2FnZQtyZWNlaXB0X2NhcA9yZWNlaXB0X3BhY2thZ2UIcmVzdHJpY3QGc2VuZGVyDXRpY2tldF9kaWdlc3QOdGlja2V0X3BhY2thZ2UNdGlja2V0X3BvbGljeQh0cmFuc2Zlcgp0eF9jb250ZXh0CXR5cGVfbmFtZQV0eXBlcw91cGdyYWRlX3BhY2thZ2UOdXBncmFkZV9wb2xpY3kHdmVyc2lvbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAIBAAIBgAIBwAUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMaCAckCAQfCAQBAgQaCAckCAY2AyUCAgIEDQgGJAgGJQIUCgIDAgINCAYkCAYAAQAAExIOADgABAQFCAsBAQcAJzgBDAILAREfDgIRGQ4CERoSAAIBAQAAAggLAAoBOAILAS4RITgDAgIBAAACBgsAEwABAREbAgMBAAATCTgBDAEOAREZCwAQABQhAgQBAAAdFzgBDAIOAhEZCgAQABQhBBEOAhEaCwAQARQhDAEFFQsAAQkMAQsBAgUBAAACAwsAEAECBgEAAAIDCwAQAAIHAQAAAgQLABACFAIIAQAAAgQLABADFAIJAQAAAgQLABAEFAIKAQAAAgQLABAFFAILAQAAAgQLABAGFAIMAQAAAgQLABAHFAINAQAAAgQLABAIFAIOAQAAAgMLABAJAg8BAAACAgcFAhABAAACAgcGAhEBAAACAgcHAhIBBAACBAsABwYRFwITAQQAAgQLAAcHERcCFAEEAAIHCwATAQEBAREbAhUBAAAeKQcIER0MAwoAEAIUCgMiBAoFDgsAAQcCJwoBCgAQBBQmBBUFGQsAAQcBJwoAEAIUDAQLAwoADwIVCwAuOAQLBAsBCwISAgIWAQAAHicLARMDDAMMAgoALjgECwIhBAsFDwsAAQcEJwoAEAIRHgcIIQQWBRoLAAEHAycLAwoADwIVCgAQAxQGAQAAAAAAAAAWCwAPAxUCFwAAAAIQCgAQBBQKASUEBwULCwABBwEnCwELAA8EFQIAAQACAQEBAgEDAgECAgMAAwECAwAHdmVjX21hcLgNoRzrCwYAAAANAQAGAgYWAxyoAQTEARwF4AH+AQfeA5kCCPcFQAa3BjIK6QYVC/4GBAyCB+sFDe0MBg7zDAYAHgEVAR8AAgcCAQAAAAAABwIBAAAAAQEHAQAAAAcAAQIBAAAOAgACAQAAFwMEAgEAABYFBAIBAAANAwYCAQAACAcIAgEAABwHCQIBAQADBwoCAQAAGgsMAgEAABALCgIBAAAFAQACAQAADwENAgEAABMLDgIBAAAMBw8CAQAACwcMAgEAAAkQEQIBAAAKEhMCAQAAGBIEAgEAAQYbGAEAAREcCgEAARQAGwEAARsYGwEAAhAZCgEAAhcXGAEAAhkfAAEABwQOBBcUFhQFBBUaFBoNBBMMCAQYFBUMFAwSDAABCwACCQAJAQMHCwACCQAJAQkACQECBwsAAgkACQEGCQACCQAJAQEHCwACCQAJAQEHCQECBgsAAgkACQEGCQABBgkBAQsCAQkBAQEBBgsAAgkACQEBAwIKCQAKCQEBCgkAAQsCAQMCBgsAAgkACQEDAgYJAAYJAQIHCwACCQAJAQMCBgkABwkBAQsBAgkACQEBBgkAAgYJAAMCBwoJAAMBCQABBgoJAAEJAQELAgEJAAEGCwIBCQABCgsBAgkACQEHCgsBAgkACQEDCQAKCQADCQEKCQEBBwoJAAQGCwECCQAJAQMKCQADAgMDAQYLAQIJAAkBAQcLAQIJAAkBBUVudHJ5Bk9wdGlvbgZWZWNNYXAIY29udGFpbnMIY29udGVudHMNZGVzdHJveV9lbXB0eQxkZXN0cm95X3NvbWUFZW1wdHkDZ2V0EGdldF9lbnRyeV9ieV9pZHgUZ2V0X2VudHJ5X2J5X2lkeF9tdXQHZ2V0X2lkeAtnZXRfaWR4X29wdAdnZXRfbXV0Bmluc2VydBBpbnRvX2tleXNfdmFsdWVzCGlzX2VtcHR5B2lzX3NvbWUDa2V5BGtleXMEbm9uZQZvcHRpb24DcG9wBnJlbW92ZRNyZW1vdmVfZW50cnlfYnlfaWR4B3JldmVyc2UEc2l6ZQRzb21lB3RyeV9nZXQFdmFsdWUHdmVjX21hcAZ2ZWN0b3IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAAAAgEECgsBAgkACQEBAgISCQAdCQEABAEEAAEAAAADQBQAAAAAAAAAADkAAgEBAAAVFAoADgEMAy4LAzgAIAQJBQ0LAAEHACcLADYACwELAjkBRBQCAgEAABYNCgALAQwCLgsCOAEMAwsANgALAzgCOgECAwEAAAAPCgA3ADgDIAQGBQoLAAEHBCcLADYARRQ6AQIEAQAAFg0KAAsBDAIuCwI4AQwDCwA2AAsDQxQ2AQIFAQAADAoKAAsBOAEMAgsANwALAkIUNwECBgEAAAkTCgAKATgABAsLAAsBOAQUOAUMAgURCwABCwEBOAYMAgsCAgcBAAAPBwsACwE4BwwCDgI4CAIIAQAAAAQLADcAQRQCCQEAAAAFCwA4CQYAAAAAAAAAACECCgEAAB0MCwA6AAwBDgE4AwQHBQkHAicLAUYUAAAAAAAAAAACCwEAAB4oCwA6AAwBDQE4CgYAAAAAAAAAAAwCDgFBFAwFQBgAAAAAAAAAAAwEQBoAAAAAAAAAAAwHCgIKBSMEIwUTDQFFFDoBDAYMAw0ECwNEGA0HCwZEGgsCBgEAAAAAAAAAFgwCBQ4LAUYUAAAAAAAAAAALBAsHAgwBAAAgIAYAAAAAAAAAAAwCCgA3AEEUDARAGAAAAAAAAAAADAMKAgoEIwQcBQ0KADcACgJCFAwBDQMLATcCFEQYCwIGAQAAAAAAAAAWDAIFCAsAAQsDAg0BAAAhJAYAAAAAAAAAAAwCCgA4CQwDCgIKAyMEHgUKCgA3AAoCQhQ3AgoBIQQZCwABCwEBCwI4CwILAgYBAAAAAAAAABYMAgUFCwABCwEBOAwCDgEAAA8NCwALATgHDAIOAjgIBAgFCgcBJwsCOA0CDwEAACIUCgEKADgJIwQGBQoLAAEHAycLADcACwFCFAwCCgI3AgsCNwECEAEAACMVCgEKAC44CSMEBwULCwABBwMnCwA2AAsBQxQMAgoCNwILAjYBAhEBAAAAEQoBCgAuOAkjBAcFCwsAAQcDJwsANgALATgCOgECAAABAQEAAAQBBAIEAAd2ZWNfc2V0rQahHOsLBgAAAA0BAAYCBgwDEmAEchQFhgFaB+ABnwEI/wJABr8DFArTAwcL2gMCDNwDkQIN7QUCDu8FAgASAQ0BEwABBwEDAAEABwEAAAAFAAEBAwAPAgEBAwAIAwABAwAOBAABAwACBQYBAwAQBwgBAwAKBwYBAwAJAQkBAwAHBQoBAwAGBQgBAwEEEAIBAAELDgYBAAEMABABAAERAhABAAIODQIBAAIPAgkBAA8CBAIJAg4CCAILCAUCDQgMCAoIAAELAAEJAAEJAAIHCwABCQAJAAIHCwABCQAGCQACBgsAAQkABgkAAQEBBgsAAQkAAQMBCgkAAQsBAQMBBgkAAgYJAAMCBwoJAAMBBgsBAQkAAgMDAQsBAQkABk9wdGlvbgZWZWNTZXQIY29udGFpbnMIY29udGVudHMMZGVzdHJveV9zb21lBWVtcHR5B2dldF9pZHgLZ2V0X2lkeF9vcHQGaW5zZXJ0CWludG9fa2V5cwhpc19lbXB0eQdpc19zb21lBG5vbmUGb3B0aW9uBnJlbW92ZQlzaW5nbGV0b24Ec2l6ZQRzb21lB3ZlY19zZXQGdmVjdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQMIAAAAAAAAAAADCAEAAAAAAAAAAAIBAwoJAAACAAEAAAADQAIAAAAAAAAAADkAAgEBAAAABAsAOAA5AAICAQAACxIKAA4BDAIuCwI4ASAECQUNCwABBwAnCwA2AAsBRAICAwEAAAwNCgALAQwCLgsCOAIMAwsANgALAzgDAQIEAQAACgcLAAsBOAQMAg4COAUCBQEAAAAECwA3AEECAgYBAAAABQsAOAYGAAAAAAAAAAAhAgcBAAAAAwsAOgACCAAAAA8jBgAAAAAAAAAADAIKADgGDAMKAgoDIwQdBQoKADcACgJCAgoBIQQYCwABCwEBCwI4BwILAgYBAAAAAAAAABYMAgUFCwABCwEBOAgCCQAAAAoNCwALATgEDAIOAjgFBAgFCgcBJwsCOAkCAAAAAgAIYmxzMTIzODGUAaEc6wsGAAAABgEAAgMCCgUMDAcYOAhQIAxwCAAAAAIAAQAAAQABAAMGCgIGCgIGCgIBAQhibHMxMjM4MRZibHMxMjM4MV9taW5fcGtfdmVyaWZ5F2JsczEyMzgxX21pbl9zaWdfdmVyaWZ5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAQIAAQECAAAIZWNkc2FfazHUAaEc6wsGAAAABwEAAgMCDwURHActQAhtIAaNARoMpwEMAAEAAgABAAAAAgEAAAMDBAADBgoCBgoCAgEKAgEGCgIEBgoCBgoCBgoCAgEBEWRlY29tcHJlc3NfcHVia2V5CGVjZHNhX2sxE3NlY3AyNTZrMV9lY3JlY292ZXIQc2VjcDI1NmsxX3ZlcmlmeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAACAQACAQEAAQIAAQECAAIBAgAACGVjZHNhX3IxtAGhHOsLBgAAAAcBAAIDAgoFDBgHJC4IUiAGchoMjAEIAAAAAQABAAACAgMAAwYKAgYKAgIBCgIEBgoCBgoCBgoCAgEBCGVjZHNhX3IxE3NlY3AyNTZyMV9lY3JlY292ZXIQc2VjcDI1NnIxX3ZlcmlmeQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAACAQACAQEAAQIAAQECAAAIdHJhbnNmZXL4AqEc6wsGAAAACAEAAgMCNgQ4BgU+CAdGkAEI1gEgBvYBCgyAAlIABwAHAAEBCAAEAAEBDAAAAgEBCAACAgEBDAAFAgEBCAADAgEBDAABAgEBCAAGAgEBCAAIAAEBCAgCBgIHAgIJAAUAAQkADWZyZWV6ZV9vYmplY3QSZnJlZXplX29iamVjdF9pbXBsFHB1YmxpY19mcmVlemVfb2JqZWN0E3B1YmxpY19zaGFyZV9vYmplY3QPcHVibGljX3RyYW5zZmVyDHNoYXJlX29iamVjdBFzaGFyZV9vYmplY3RfaW1wbAh0cmFuc2Zlcg10cmFuc2Zlcl9pbXBsAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAAEAAAEECwALATgAAgEBAAABBAsACwE4AAICAQAAAQMLADgBAgMBAAABAwsAOAECBAEAAAEDCwA4AgIFAQAAAQMLADgCAgYDAgAHAwIACAMCAAAJdGFibGVfdmVjsgahHOsLBgAAAA0BAAYCBhIDGGcEfxQFkwGKAQedAp8BCLwDIAbcAxQK8AMKC/oDAgz8A/UBDfEFAg7zBQIAEQAQABIAAQQBBAEBAAwCBwEEAQICAgAACAABAQQADwIBAQQACgMEAQQACQMFAQQABAYHAQQADQgJAQQABQoLAQQADAwNAQQABwEJAQQBAxMJAgcEAQQREgIHBAEFFBUCBwQBBw8JAgcEAQoQBAIHBAELAA8CBwQBDhQWAgcEDg4ADQUNDQ4CDQoOCQ4LDg8ODA4BBwgCAQsAAQkAAgkABwgCAQYLAAEJAAEDAQECBgsAAQkAAwEGCQACBwsAAQkACQAAAgcLAAEJAAMBBwkAAQcLAAEJAAEJAAIDCQABCwECCQAJAQEGCwECCQAJAQIGCwECCQAJAQkAAQYJAQMHCwECCQAJAQkACQECBwsBAgkACQEJAAEHCQEBCQEFVGFibGUIVGFibGVWZWMJVHhDb250ZXh0A2FkZAZib3Jyb3cKYm9ycm93X211dAhjb250ZW50cw1kZXN0cm95X2VtcHR5BWVtcHR5CGlzX2VtcHR5Bmxlbmd0aANuZXcIcG9wX2JhY2sJcHVzaF9iYWNrBnJlbW92ZQlzaW5nbGV0b24FdGFibGUJdGFibGVfdmVjCnR4X2NvbnRleHQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAADCAEAAAAAAAAAAAIBBgsBAgMJAAANAAEAAAkECwA4ADkAAgEBAAABCAsBOAEMAg0CCwA4AgsCAgIBAAAJBAsANwA4AwIDAQAACQULADgEBgAAAAAAAAAAIQIEAQAACQ8KADgECgEkBAYFCgsAAQcAJwsANwALATgFAgUBAAAECgoALjgEDAILADYACwILATgGAgYBAAAJEAoALjgECgEkBAcFCwsAAQcAJwsANgALATgHAgcBAAAEFAoALjgEDAEKAQYAAAAAAAAAACQECQUNCwABBwAnCwA2AAsBBgEAAAAAAAAAFzgIAggBAAAJDA4AOAQGAAAAAAAAAAAhBAYFCAcBJwsAOgA4CQIAAAANAAl2ZXJzaW9uZWT+BaEc6wsGAAAACwEACAIIFAMcVQRxCgV7YQfcAewBCMgDIAboAwoK8gMQDIIExQENxwUEABcACwAQABQABAwAAAMAAAIABwACAgQAAwECAAAIAAEBBAAWAgMAAA0CBAEEAA4FBgEEABMFBwEEABUICQEEAAoBCgEEAQUOCQIHBAEGDxACBwQBBxESAgcEARIREwIHBAIJDAkAAgwEFAEIAg8LDAAHDQgNCQ0KDQwBAwMJAAcIBAEIAAEGCAABAwEGCQABBwgAAQcJAAIJAAgBBAcIAAMJAAgBAAEJAAEHCAQBCAMCAwkAAwcIAwkACQECBggDCQABBgkBAgcIAwkAAQcJAQEJAQEIAgMIAwkAAwJJRAlUeENvbnRleHQDVUlEEFZlcnNpb25DaGFuZ2VDYXAJVmVyc2lvbmVkA2FkZAZib3Jyb3cKYm9ycm93X211dAZjcmVhdGUGZGVsZXRlB2Rlc3Ryb3kNZHluYW1pY19maWVsZAJpZApsb2FkX3ZhbHVlDmxvYWRfdmFsdWVfbXV0A25ldwZvYmplY3QLb2xkX3ZlcnNpb24GcmVtb3ZlGHJlbW92ZV92YWx1ZV9mb3JfdXBncmFkZQp0eF9jb250ZXh0B3VwZ3JhZGUHdmVyc2lvbgl2ZXJzaW9uZWQMdmVyc2lvbmVkX2lkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAAICDAgDFgMBAgIYCAIRAwABAAABDAsCEQ0KABIADAMNAw8ACwALATgACwMCAQEAAAkECwAQARQCAgEAAAkHCgAQAAsAEAEUOAECAwEAAAkHCgAPAAsAEAEUOAICBAEAAAkOCgAPAAoAEAEUOAMKAC44BAsAEAEUEgECBQEAAAMgCwMTAQwECgAuOAQhBAkFDQsAAQcAJwsECgEjBBIFFgsAAQcAJwoADwAKAQsCOAALAQsADwEVAgYBAAAVDAsAEwAMAwwBDQELAzgDDAILARELCwICAAAAAQAKb2JqZWN0X2JhZ+kGoRzrCwYAAAALAQAKAgoWAyB8BJwBDgWqAVgHggLnAQjpA0AGqQQKCrMECAy7BPUBDbAGBAAUARUADAATABgAAQwAAQIHAQAAAwAHAAMEBAAEAwIAABIAAQAABQIDAgcMAAYEBQIHDAAHBgcCBwwAFgYIAgcMAAgECQEHAAkECQIHDAARCgsAABAKCQAACwEDAAAZBAwBBwIFDwMCBwwCBhAFAgcMAgcRBwIHDAINEAkBBwIOEAkCBwwCDxAMAQcCFhEIAgcMAwoNAwADEgANAAsODA4NDhEODhIPDhASAQcIBAEIAAMHCAAJAAkBAAIGCAAJAAEGCQECBwgACQABBwkBAQkBAQEBBggAAQMBCwEBCAIBCAMCCQAJAQMHCAMJAAkBAgYIAwkAAgcIAwkAAQkAAggDAwJJRAlPYmplY3RCYWcGT3B0aW9uCVR4Q29udGV4dANVSUQDYWRkBmJvcnJvdwpib3Jyb3dfbXV0CGNvbnRhaW5zEmNvbnRhaW5zX3dpdGhfdHlwZQZkZWxldGUNZGVzdHJveV9lbXB0eRRkeW5hbWljX29iamVjdF9maWVsZAdleGlzdHNfEGV4aXN0c193aXRoX3R5cGUCaWQIaXNfZW1wdHkGbGVuZ3RoA25ldwZvYmplY3QKb2JqZWN0X2JhZwZvcHRpb24GcmVtb3ZlBHNpemUKdHhfY29udGV4dAh2YWx1ZV9pZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAAICDwgDFwMAAQAAAwULABETBgAAAAAAAAAAEgACAQEAAAMOCgAPAAsBCwI4AAoAEAEUBgEAAAAAAAAAFgsADwEVAgIBAAADBQsAEAALATgBAgMBAAADBQsADwALATgCAgQBAAAIDwoADwALATgDDAIKABABFAYBAAAAAAAAABcLAA8BFQsCAgUBAAADBQsAEAALATgEAgYBAAADBQsAEAALATgFAgcBAAADBAsAEAEUAggBAAADBgsAEAEUBgAAAAAAAAAAIQIJAQAAEw4LABMADAIMAQsCBgAAAAAAAAAAIQQJBQsHACcLARESAgoBAAADBQsAEAALATgGAgAAAAEACnR4X2NvbnRleHT5AqEc6wsGAAAACgEAAgICBAMGHgUkFAc4aAigASAGwAEUCtQBDgziAWANwgIKAAcAAAIAAAYAAQAAAgACAAADAAIAAAQDAQAABQACAAABBAEAAQYIAAEFAQMBBwgAAgoCAwACBQMJVHhDb250ZXh0CWRlcml2ZV9pZAVlcG9jaBJlcG9jaF90aW1lc3RhbXBfbXMUZnJlc2hfb2JqZWN0X2FkZHJlc3MLaWRzX2NyZWF0ZWQGc2VuZGVyCnR4X2NvbnRleHQHdHhfaGFzaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwggAAAAAAAAAAMIAAAAAAAAAAAAAgUGBQgKAgIDAwMFAwABAAAFBAsAEAAUAgEBAAAFBAsAEAEUAgIBAAAFBAsAEAIUAgMBAAAGEgoAEAMUDAIKABAEFAoCEQUMAQsCBgEAAAAAAAAAFgsADwMVCwECBAAAAAUECwAQAxQCBQACAAAAAAIAAwAEAAEADGxpbmtlZF90YWJsZZENoRzrCwYAAAANAQAKAgoeAyjUAQT8ARwFmAK8AQfUA80CCKEGQAbhBhQK9QYmC5sHBAyfB5cFDbYMDg7EDA4AGAEdAA4AHAAoAAAMAgcABAEAAQQCBwAEAAECBwEAAAMEBAAEAwIAABkAAQIHBAARAgMCBwQABgIDAgcEACIEBQIHBAAhBAUCBwQABwYHAgcEAAgICQIHBAAgBgMCBwQAGgYDAgcEACMICgIHBAAfCwwCBwQAHgsMAgcEAAkGDQIHBAAXAg4CBwQAFAINAgcEAAsBBQIHBAANAQUCBwYBBwMZAQABDBEQAQABEBMFAQABFQMNAQABFgMNAQABGwURAQABJRARAQABJhMRAQACBRYFAgcEAgcXBwIHBAIIFQkCBwQCDxcNAgcEAiMVCgIHBAMKDwUAAxkADwAWEBgQFBATEBUQEhAXEBsUGRQaFB0UERAJDBwUAQcIBAELAAIJAAkBAQYLAAIJAAkBAQYLAgEJAAMHCwACCQAJAQkACQEAAgYLAAIJAAkBCQABBgkBAgcLAAIJAAkBCQABBwkBAQkBAQcLAAIJAAkBAgkACQEBAQEDAQgDAQkAAQsCAQkABQsCAQkACwIBCQALAgEJAAkACwIBCQACBwsCAQkACQACCQALAQIJAAkBAgcIAwkAAwcIAwkACQECBggDCQADCwIBCQALAgEJAAkBAQYJAAIIAwMLTGlua2VkVGFibGUETm9kZQZPcHRpb24JVHhDb250ZXh0A1VJRANhZGQEYmFjawZib3Jyb3cKYm9ycm93X211dAhjb250YWlucwZkZWxldGUNZGVzdHJveV9lbXB0eQxkZXN0cm95X3NvbWUEZHJvcA1keW5hbWljX2ZpZWxkEGV4aXN0c193aXRoX3R5cGUEZmlsbAVmcm9udARoZWFkAmlkCGlzX2VtcHR5B2lzX25vbmUHaXNfc29tZQZsZW5ndGgMbGlua2VkX3RhYmxlA25ldwRuZXh0BG5vbmUGb2JqZWN0Bm9wdGlvbghwb3BfYmFjawlwb3BfZnJvbnQEcHJldglwdXNoX2JhY2sKcHVzaF9mcm9udAZyZW1vdmUEc2l6ZQRzb21lDHN3YXBfb3JfZmlsbAR0YWlsCnR4X2NvbnRleHQFdmFsdWUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAAAAgQTCAMkAxILAgEJACcLAgEJAAECAyALAgEJABoLAgEJACkJAQAMAQwAAQAABQcLABEfBgAAAAAAAAAAOAA4ADkAAgEBAAAFAwsANwACAgEAAAUDCwA3AQIDAQAAEjYKADYACgE4AQwFCgA3ATgCBA0KADYBCgE4AzgADAcOBTgEBCELBTgFDAYKATgGCgA2AgoGOAc2AxULBjgGDAMFIzgADAMLAwwECgA2AgsBCwcLBAsCOQE4CAoANwQUBgEAAAAAAAAAFgsANgQVAgQBAAASNgoANwA4AgQICgA2AAoBOAMKADYBCgE4AQwFDgU4BAQfCwU4BQwGCgE4BgoANgIKBjgHNgUVCwY4BgwDBSE4AAwDCwMMBzgADAQKADYCCwELBwsECwI5ATgICgA3BBQGAQAAAAAAAAAWCwA2BBUCBQEAAAUGCwA3AgsBOAk3BgIGAQAABQYLADYCCwE4BzYGAgcBAAAFBgsANwILATgJNwMCCAEAAAUGCwA3AgsBOAk3BQIJAQAAGEEKADYCCgE4CjoBDAQMAgwDCgA3BBQGAQAAAAAAAAAXCgA2BBUOAzgEBBwKAgoANgIOAzgLFDgHNgUVDgI4BAQoCgMKADYCDgI4CxQ4BzYDFQoANwA4Cw4BIQQyCwIKADYAFQoANwE4Cw4BIQQ9CwMLADYBFQU/CwABCwQCCgEAABATCgA3ADgEBAUFCQsAAQcBJwoANwA4CxQMAQoBCwALATgMAgsBAAAQEwoANwE4BAQFBQkLAAEHAScKADcBOAsUDAEKAQsACwE4DAIMAQAABQULADcCCwE4DQINAQAABQQLADcEFAIOAQAABQYLADcEFAYAAAAAAAAAACECDwEAABoQCwA6AAEBDAIMAQsCBgAAAAAAAAAAIQQLBQ0HACcLAREeAhABAAAFBwsAOgABAQERHgIAAgADAAABAAABAQEBAgAMAQwCDAMMBAwFDAYMAAxvYmplY3RfdGFibGXfBqEc6wsGAAAADQEACgIKGgMkeAScAQwFqAFxB5kCxwEI4ANABqAECgqqBAgLsgQCDLQE5gENmgYEDp4GBAASARMACwARABYAAQwCBwEMAQECBwEAAAMABwADBAQABAMCAAAQAAECBwwABQIDAgcMAAYEBQIHDAAHBgcCBwwAFAYIAgcMAAgECQIHDAAPCgsCBwwADgoJAgcMAAoBAwIHDAAXBAwCBwwCBQ8DAgcMAgYQBQIHDAIHEQcCBwwCDBAJAQcCDRAMAQcCFBEIAgcMAwkNAwADEAANAAoOCw4MDg8ODRIOEgEHCAQBCwACCQAJAQMHCwACCQAJAQkACQEAAgYLAAIJAAkBCQABBgkBAgcLAAIJAAkBCQABBwkBAQkBAQEBBgsAAgkACQEBAwELAQEIAgEIAwIJAAkBAwcIAwkACQECBggDCQACBwgDCQABCQACCAMDAklEC09iamVjdFRhYmxlBk9wdGlvbglUeENvbnRleHQDVUlEA2FkZAZib3Jyb3cKYm9ycm93X211dAhjb250YWlucwZkZWxldGUNZGVzdHJveV9lbXB0eRRkeW5hbWljX29iamVjdF9maWVsZAdleGlzdHNfAmlkCGlzX2VtcHR5Bmxlbmd0aANuZXcGb2JqZWN0DG9iamVjdF90YWJsZQZvcHRpb24GcmVtb3ZlBHNpemUKdHhfY29udGV4dAh2YWx1ZV9pZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAAICDQgDFQMADgABAAADBQsAEREGAAAAAAAAAAA5AAIBAQAAAw4KADYACwELAjgACgA3ARQGAQAAAAAAAAAWCwA2ARUCAgEAAAMFCwA3AAsBOAECAwEAAAMFCwA2AAsBOAICBAEAAAgPCgA2AAsBOAMMAgoANwEUBgEAAAAAAAAAFwsANgEVCwICBQEAAAMFCwA3AAsBOAQCBgEAAAMECwA3ARQCBwEAAAMGCwA3ARQGAAAAAAAAAAAhAggBAAATDgsAOgAMAgwBCwIGAAAAAAAAAAAhBAkFCwcAJwsBERACCQEAAAMFCwA3AAsBOAUCAAAAAQAOAQ4ADWR5bmFtaWNfZmllbGSWCqEc6wsGAAAADgEABgIGFgMchQEEoQEYBbkBqAEH4QKBAwjiBUAGogYoCsoGDAvWBgIM2AbrAg3DCQYOyQkID9EJAgALARoAGQAACAIHAAQAAQIHAQAAAgEHAAIDBAAABAABAgcEAAYCAwIHBAAJBAUCBwQAGwQGAgcEAA0CBwEHAB0ECAIHBAAOAgcCBwQADwIJAQcAEAQKAQcAEwsMAQcABQsBAQgABwkNAQgACAoOAQgAHA8QAQgAEQ8HAAASDwcBCAEYARgBAAEeEBgBAAIKEwEAAhUcDAACFwwTAAIfEgwACRAKFQsVDBUNFQQQAxQRBhAGDxULGgwaAwcIAwkACQEAAgYIAwkAAQYJAQIHCAMJAAEHCQEBCQEBAQELAQEJAQIGCAMFAgcIAwUCBQkAAQUBBgkAAQcJAAIFBQEJAAMLAAIJAAkBBQUBBggDAQgDAgkACQEBCwACCQAJAQMFBQkBAgkACwEBCQEBCwEBCQAEBgsAAgkACAIFBggDBggCAQsAAgkACAICCQAIAgEGCAIEBwsAAgkACAIFBwgDBwgCBUZpZWxkAklEBk9wdGlvbgNVSUQDYWRkEGFkZF9jaGlsZF9vYmplY3QGYm9ycm93E2JvcnJvd19jaGlsZF9vYmplY3QXYm9ycm93X2NoaWxkX29iamVjdF9tdXQKYm9ycm93X211dAZkZWxldGUNZHluYW1pY19maWVsZBRkeW5hbWljX29iamVjdF9maWVsZAdleGlzdHNfEGV4aXN0c193aXRoX3R5cGUKZmllbGRfaW5mbw5maWVsZF9pbmZvX211dBBoYXNfY2hpbGRfb2JqZWN0GGhhc19jaGlsZF9vYmplY3Rfd2l0aF90eRFoYXNoX3R5cGVfYW5kX2tleQJpZA1pZF90b19hZGRyZXNzBG5hbWURbmV3X3VpZF9mcm9tX2hhc2gEbm9uZQZvYmplY3QGb3B0aW9uBnJlbW92ZRNyZW1vdmVfY2hpbGRfb2JqZWN0EHJlbW92ZV9pZl9leGlzdHMEc29tZQ51aWRfdG9fYWRkcmVzcwV2YWx1ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAAIDFAgDFgkAIAkBABQAAQAAERoLAC4RFQwFCgUKATgADAQKBQoEEQ4gBA4FEAcAJwsEERQLAQsCOQAMAwsFCwM4AQIBAQAADAoKABEVCwE4AAwCCwALAjgCNwACAgEAAAwLCgAuERULATgADAILAAsCOAM2AAIDAQAAFhELAC4RFQwDCgMLATgADAILAwsCOAQ6AAwEARESCwQCBAEAAA8LCwARFQwDCgMLATgADAILAwsCEQ4CBQEAABcTCgAKAQwCLgsCOAUEDQsACwE4BjgHDAMFEQsAATgIDAMLAwIGAQAADwsLABEVDAMKAwsBOAAMAgsDCwI4CQIHAwAAGRYKABEVCwE4AAwDCwALAzgKDAIKAjcBDAQKAjcCAQsCNwMMBQsECwUREwIIAwAAHRgKAC4RFQsBOAAMAwsACwM4CwwCCgI2AQwECgI2AgELAjYDDAULBAsFLhETAgkDAgAKAwIACwMCAAwDAgANAwIADgMCAA8DAgAAAgAAAAEAFAEbAhsAGwAMAA5wcmlvcml0eV9xdWV1ZdAKoRzrCwYAAAANAQAEAgQMAxA8BEwKBVanAQf9AbgBCLUDQAb1Aw4KgwQSC5UEBAyZBPMFDYwKBA6QCgQACwEQAAEGAQIAAAAGAQIAAAYAAQECAAgCAwECAAQEBQECAAcDBgECAAIHAAECAA0IBQECAAUJBQECAAkKCwECAQwPDQEAAQ4PDQEABg0JBgUNCBAIDQEKCwEBCQABCwABCQABBwsAAQkAAgMJAAMHCwABCQADCQAAAQsBAQkAAgoDCgkAAgcKCwEBCQADAwcKCwEBCQADAwEGCwABCQABCgMCAwMBCQADAwMJAAIHCgkAAwEDBQMDAwoLAQEJAAkABQcKCwEBCQADBwoLAQEJAAMDDQcKCwEBCQABAwcKCwEBCQADAQcKCwEBCQADBwoLAQEJAAMDAwMCAwoDBUVudHJ5DVByaW9yaXR5UXVldWUOY3JlYXRlX2VudHJpZXMHZW50cmllcwZpbnNlcnQVbWF4X2hlYXBpZnlfcmVjdXJzaXZlA25ldwluZXdfZW50cnkHcG9wX21heApwcmlvcml0aWVzCHByaW9yaXR5DnByaW9yaXR5X3F1ZXVlBnJlbW92ZRZyZXN0b3JlX2hlYXBfcmVjdXJzaXZlC3N3YXBfcmVtb3ZlBXZhbHVlBnZlY3RvcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDCAAAAAAAAAAACgMBAAACAQMKCwEBCQABAgIKAw8JAAANAQ0AAQAADBgOAEEGDAIKAgYCAAAAAAAAABoMAQoBBgAAAAAAAAAAJAQVBQwLAQYBAAAAAAAAABcMAQ0ACgIKATgABQcLADkAAgEBAAAOHgoANwBBBgwBCgEGAAAAAAAAAAAkBAkFDQsAAQcAJwoANgAGAAAAAAAAAAA4AToBDAMMAgsANgALAQYBAAAAAAAAABcGAAAAAAAAAAA4AAsCCwMCAgEAABARCgA2AAsBCwI5AUQGCgA3AEEGBgEAAAAAAAAAFwwDCwA2AAsDOAICAwEAAAUECwALATkBAgQBAAARKA4AQRAMAw4BQQ0KAyEECQULBgAAAAAAAAAAJ0AGAAAAAAAAAAAMBQYAAAAAAAAAAAwCCgIKAyMEJgUUDQAGAAAAAAAAAAA4AwwEDQEGAAAAAAAAAAA4BAwGDQULBAsGOQFEBgsCBgEAAAAAAAAAFgwCBQ8LBQIFAAAAEi4KAQYAAAAAAAAAACEEBwsAAQIKAQYBAAAAAAAAABcGAgAAAAAAAAAaDAYKAAoBDAMMAgoACgYMBQwECwIuCwNCBjcBFAsELgsFQgY3ARQkBCsKAAsBCgZHBgsACwY4AgUtCwABAgYAAAATbgoBBgAAAAAAAAAAIQQHCwABAgoCCgEjBAwFEAsAAQYBAAAAAAAAACcKAgYCAAAAAAAAABgGAQAAAAAAAAAWDA0KDQYBAAAAAAAAABYMDwoCDA4KDQoBIwQ3CgAKDQwFDAMKAAoODAcMBgsDLgsFQgY3ARQLBi4LB0IGNwEUJAwIBTkJDAgLCAQ9Cw0MDgoPCgEjBFgKAAoPDAoMCQoACg4MDAwLCwkuCwpCBjcBFAsLLgsMQgY3ARQkDAQFWgkMBAsEBF4LDwwOCg4KAiIEawoACg4LAkcGCwALAQsOOAAFbQsAAQIHAQAAFBwHAQwCBgAAAAAAAAAADAEKAQoANwBBBiMEGAULDQIKADcACgFCBjcBFEQQCwEGAQAAAAAAAAAWDAEFBAsAAQsCAgAAAQAADQENAA90cmFuc2Zlcl9wb2xpY3n7EaEc6wsGAAAADQEAGAIYTgNm8wEE2QIqBYMDlgMHmQblBAj+CkAGvgs8CvoLNwuxDAoMuwzhBA2cERAOrBEQADsBLwE9ABMAFQAcAB8ALgAwADkAPABCAAoAAQABAAcMAQABAAgMAQABAAkDAQABAAUHAQIBAQMHAQAAAgwHAAMABAEAAQQBDAEAAQcCBwAHDQQACAQMAAkGAgAKCwIACw4HAQMAAC0AAQEAACwCAwEAAEMEBQEAABkGBQEAABYHAAEAABEICQMAAgYAJQoLAwACBgASDAkCAAIAEA0JAgACACYODwIAAgA2EAkDAAIGAD4OEQEAAD8QEgEAACsTFAEAADETFQEAACETFAEAARokGAEAASojDwEAAiQJFgEAA0ElFQEAA0QJHwEABCIpJwEABDM1CQEABDomJwEABQ8xCQIHBAUUMzQCBwQFIDMPAQcFNTcvAgcEBh0YCQEDBxgcCQAHJyIUAQgHLBscAAdAERQACCMaDwEACxctDwEDCx4JFwEDCygyCQEDCykXKwEDCzgsFQEDIxYhGBwdFB4eIREVEBUTHhceFR4lFiYWIhYJLhgwEi8kFhkwFh4aNhswAwgJAwgJAQsAAQkAAgYICwcIDQILAQEJAAsCAQkABAcLAQEJAAYLAgEJAAsFAQMHCA0BCwgBCAwDCwEBCQALAgEJAAcIDQIGCwEBCQALAAEJAAQJAQcLAQEJAAYLAgEJAAkCAAIJAQYLAQEJAAEGCQIDCQEHCwEBCQALCAEIDAIJAQcLAAEJAAEGCwEBCQABAQIHCwEBCQAGCwIBCQABBggKAQcICgEGCwABCQABCAkBAwEIBgELDgEJAAEJAAUICgsOAQgGCwcBCAwICggJAQYICwEHCA0BCAoBCwMBCQABCAwBCwcBCQADAwMDAQsBAQkAAQYJAAEGCwUBCQABCwUBCQABBgsHAQkAAwcLBwEJAAMHCA0BCwgBCQACCwcBCAwICgILBwEJAAcIDQcKCAYICQgJAwsOAQgGCAYDAQoJAAEGCw4BCQACBgsOAQkABgkAAgkACQEBCQECCwQBCQEJAgMHCAoJAAkBAgcLDgEJAAkAAgYICgkAAQYJAQIHCwcBCQALCAEJAAELBAEJAQIHCAoJAAdCYWxhbmNlBENvaW4CSUQGT3B0aW9uCVB1Ymxpc2hlcgdSdWxlS2V5A1NVSQ5UcmFuc2ZlclBvbGljeRFUcmFuc2ZlclBvbGljeUNhcBVUcmFuc2ZlclBvbGljeUNyZWF0ZWQPVHJhbnNmZXJSZXF1ZXN0CVR4Q29udGV4dAhUeXBlTmFtZQNVSUQGVmVjU2V0A2FkZAthZGRfcmVjZWlwdAhhZGRfcnVsZQ5hZGRfdG9fYmFsYW5jZQdiYWxhbmNlBmJvcnJvdwRjb2luD2NvbmZpcm1fcmVxdWVzdAhjb250YWlucwZkZWxldGUUZGVzdHJveV9hbmRfd2l0aGRyYXcMZGVzdHJveV9zb21lC2R1bW15X2ZpZWxkDWR5bmFtaWNfZmllbGQEZW1pdAVlbXB0eQVldmVudAdleGlzdHNfBGZyb20MZnJvbV9iYWxhbmNlDGZyb21fcGFja2FnZQNnZXQIZ2V0X3J1bGUIaGFzX3J1bGUCaWQGaW5zZXJ0CWludG9fa2V5cwdpc19zb21lBGl0ZW0DbmV3C25ld19yZXF1ZXN0Bm9iamVjdAZvcHRpb24HcGFja2FnZQRwYWlkCXBvbGljeV9pZANwdXQIcmVjZWlwdHMGcmVtb3ZlC3JlbW92ZV9ydWxlBXJ1bGVzBHNpemUDc3VpBHRha2UPdHJhbnNmZXJfcG9saWN5CnR4X2NvbnRleHQJdHlwZV9uYW1lA3VpZBB1aWRfbXV0X2FzX293bmVyDHVpZF90b19pbm5lcgV2YWx1ZQd2ZWNfc2V0CHdpdGhkcmF3BHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAAIEKwgJMQMhCAk0Cw4BCAYBAgMnCAoTCwcBCAw3Cw4BCAYCAgInCAoyCAkDAgEnCAkEAgEbAQAYAxgBGAIYBC8AAQAACQYLAAsBCwI4ADkAAgEBAAAZIAsAOAEEBAUICwEBBgAAAAAAAAAAJwoBER8MBQ4FESAMBgoGOQE4AgsFDAI4AAwDOAMMBAsCCwQLAzkCCwERHwsGOQMCAgEAACAxCgAuOAQLATcAFCEECQUPCwABCwMBBwQnDgI4BQQlCwI4BgwGCgYKADcBOAclBBwFIgsAAQsDAQcFJwsGDAQFKQoANwE4BwwECwQMBQsANgELBQsDOAgCAwEAACgbDgA4BA4BNwAUIQQIBQwLAgEHBCcLAToDAQwECwA6AgEMAxEdCwQRHQsDCwI4CQIEAQAAKjQLAToADAYMAwwFDAQLBjgKDAIOAkEWDAgKCAoANwI4CyEEEwUXCwABBwAnCggGAAAAAAAAAAAkBC4FHA0CRRYMBwoANwIOBzgMBCUFKQsAAQcBJwsIBgEAAAAAAAAAFwwIBRcLAAELBAsFCwMCBQEAAAkiCgEuOAQLAjcAFCEECQUNCwEBBwQnCgEuOA0gBBMFFwsBAQcDJwoBNgMJOQQLAzgOCwE2AjgPOBACBgEAAAkGCwE3Awk5BDgRAgcBAAAJDgoBLjgNBAUFCQsBAQcCJwsBNgELAjgSAggBAAAJBQsBNgQ4DzgQAgkBAAAJBgsANwMJOQQ4EwIKAQAACRQKAC44BAsBNwAUIQQJBQ0LAAEHBCcLADYDCTkEOBQBAgsBAAAJAwsANwMCDAEAAAkQCgAuOAQLATcAFCEECQUNCwABBwQnCwA2AwINAQAACQQLADcFFAIOAQAACQQLADcGFAIPAQAACQQLADcHFAICAQEBAQIBAAADAAAAAQACABgBGAIYAxgEGAUYBhgHGAAUZHluYW1pY19vYmplY3RfZmllbGTZB6Ec6wsGAAAACgEACAIIFAMcigEEpgEaBcABgwEHwwKyAgj1BEAKtQUGC7sFAgy9BekBAAsBFgAKABUAAwcBAAABAQcBAAADAAcAAwIEAAAEAAECBwwABgIDAgcMAAkEBQIHDAAXBAYCBwwADAIHAQcADQIHAgcMABECCAEHARQBGAEAARkKGAEAAgQAAQIHBAIFEgEBCAIHDwsBCAIIExQBCAINAgcCBwQCDgIPAQcCDwQTAQcCEBYHAQgCFwQGAgcEAhgWCgEIAxELDAEIAxIRDAADGhARABMGCQ0ODgoGCwYPDgwGEgYRDQ0NEAYHDAgMAwcIAwkACQEAAgYIAwkAAQYJAQIHCAMJAAEHCQEBCQEBAQELAQEIAgMLAAEJAAgCCwABCQABCQABBgkAAQgCAgsAAQkACAIBCwABCQACBggDBQEGCAMBBQIFCQACBwgDBQEHCQAECwABCQALAAEJAAkBBQIFBQILAAEJAAUBCwEBCQACSUQGT3B0aW9uA1VJRAdXcmFwcGVyA2FkZBBhZGRfY2hpbGRfb2JqZWN0BmJvcnJvdxNib3Jyb3dfY2hpbGRfb2JqZWN0F2JvcnJvd19jaGlsZF9vYmplY3RfbXV0CmJvcnJvd19tdXQNZHluYW1pY19maWVsZBRkeW5hbWljX29iamVjdF9maWVsZAdleGlzdHNfEGV4aXN0c193aXRoX3R5cGUKZmllbGRfaW5mbw5maWVsZF9pbmZvX211dBhoYXNfY2hpbGRfb2JqZWN0X3dpdGhfdHkCaWQPaWRfZnJvbV9hZGRyZXNzBG5hbWUEbm9uZQZvYmplY3QGb3B0aW9uBnJlbW92ZRNyZW1vdmVfY2hpbGRfb2JqZWN0BHNvbWUOdWlkX3RvX2FkZHJlc3MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAIBEwkAAAoAAQAACRULATkADAUOAjgADAQKAAoFCwQ4AQsACwUMAy4LAzgCAREVCwI4AwIBAQAADggLATkADAILAAsCOAI4BAICAQAADggLATkADAILAAsCOAU4BgIDAQAAFRQLATkADAMKAAoDDAIuCwI4AgwFERULBTgHDAQLAAsDOAgBCwQCBAEAAA4HCwE5AAwCCwALAjgJAgUBAAAXFAsBOQAMAgoACgI4CSAEDAsAAQkCCwALAjgCDAMRFQsDOAoCBgEAABcVCwE5AAwCCgAKAjgJIAQMCwABOAsCCwALAjgCDAMBCwMRFDgMAgA2CnR4X2NvbnRleHQJVHhDb250ZXh0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGb2JqZWN0AklEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGb2JqZWN0A1VJRAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNiYWcDQmFnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHYmFsYW5jZQZTdXBwbHkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdiYWxhbmNlB0JhbGFuY2UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgNiY3MDQkNTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGYm9ycm93CFJlZmVyZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGYm9ycm93BkJvcnJvdwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBWNsb2NrBUNsb2NrAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDdXJsA1VybAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBGNvaW4EQ29pbgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBGNvaW4MQ29pbk1ldGFkYXRhAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEY29pbgtUcmVhc3VyeUNhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBGNvaW4PQ3VycmVuY3lDcmVhdGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHdmVjX21hcAZWZWNNYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgd2ZWNfbWFwBUVudHJ5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHcGFja2FnZQlQdWJsaXNoZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdwYWNrYWdlClVwZ3JhZGVDYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdwYWNrYWdlDVVwZ3JhZGVUaWNrZXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdwYWNrYWdlDlVwZ3JhZGVSZWNlaXB0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHZGlzcGxheQdEaXNwbGF5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHZGlzcGxheQ5EaXNwbGF5Q3JlYXRlZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2Rpc3BsYXkOVmVyc2lvblVwZGF0ZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhRkeW5hbWljX29iamVjdF9maWVsZAdXcmFwcGVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHZ3JvdGgxNgVDdXJ2ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB2dyb3RoMTYUUHJlcGFyZWRWZXJpZnlpbmdLZXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgdncm90aDE2EVB1YmxpY1Byb29mSW5wdXRzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIHZ3JvdGgxNgtQcm9vZlBvaW50cwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACB3ZlY19zZXQGVmVjU2V0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDc3VpA1NVSQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACD3RyYW5zZmVyX3BvbGljeQ9UcmFuc2ZlclJlcXVlc3QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg90cmFuc2Zlcl9wb2xpY3kOVHJhbnNmZXJQb2xpY3kAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg90cmFuc2Zlcl9wb2xpY3kRVHJhbnNmZXJQb2xpY3lDYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg90cmFuc2Zlcl9wb2xpY3kVVHJhbnNmZXJQb2xpY3lDcmVhdGVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIPdHJhbnNmZXJfcG9saWN5B1J1bGVLZXkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawVLaW9zawAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBWtpb3NrDUtpb3NrT3duZXJDYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawtQdXJjaGFzZUNhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBWtpb3NrBEl0ZW0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgVraW9zawdMaXN0aW5nAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFa2lvc2sETG9jawAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBWtpb3NrCkl0ZW1MaXN0ZWQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgxsaW5rZWRfdGFibGULTGlua2VkVGFibGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgxsaW5rZWRfdGFibGUETm9kZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACCm9iamVjdF9iYWcJT2JqZWN0QmFnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIMb2JqZWN0X3RhYmxlC09iamVjdFRhYmxlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIOcHJpb3JpdHlfcXVldWUNUHJpb3JpdHlRdWV1ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDnByaW9yaXR5X3F1ZXVlBUVudHJ5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFdGFibGUFVGFibGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgl0YWJsZV92ZWMIVGFibGVWZWMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgl2ZXJzaW9uZWQJVmVyc2lvbmVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIJdmVyc2lvbmVkEFZlcnNpb25DaGFuZ2VDYXAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQAAAAAAAAADIHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMBAAAAAAAAAAsHZ2VuZXNpc/YSoRzrCwYAAAAKAQAaAho6A1RrBL8BDgXNAbACB/0DiQkIhg1gCuYNXQzDDukDDawSGAAfASwBSAISAhQCKwI9AkIANgA/AEAAQwBGAAMDAAACAwAACQAAAAgAAAEEBwEAAAMABAEAAQQBDAEAAQULBAAGBQIABwoCAAgGBAAKBwQACwwEAAAWAAEAAA8CAQAADgMBAAEZGRoBAAEkGA4BAAIjFg4BAAMaCQEBAAM1CAkBAANLAQkBAAQdHh8BAAZBIAEABxsFBgAIFhESAAkWEwEAChcPEAALDSIBAAsqDAoACzQdAQAMIBscAAwiDQ4ABwcIBwUVBBcDFwkHBgcGCAcLBQEICAgBCggACAIHCAkABAsFAQgICggDBwoIDAcICQEHCggMGQoIAwMDCgIDAwoCCgIKAgoCCgIKAgoCCgIKAggKAwsFAQgICwUBCAgFCAsIDAoIDAoCCgIBBggJAQMBCAgCBwsFAQkAAwELBQEJAAEIDAEIABAFCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCAwMHCAkCBgoIDAYIDAEBCAMDAwMDAwMHCAkBCAsFCwUBCAgDAw0HCAkBCAoICAcKCAwLBQEICAMDCAsICgcICQULBQEICAMFCwQBBQUBCAMBBgoJAAEFAQYLBAEJAAELBAEJAAEJAAIHCggMBQEHCAwEBwgMCwUBCAgFBwgJAgsFAQkABwgJAQsGAQkAAgsGAQgIBQIDAwIHCAwDB0JhbGFuY2UEQ29pbhZHZW5lc2lzQ2hhaW5QYXJhbWV0ZXJzGEdlbmVzaXNWYWxpZGF0b3JNZXRhZGF0YQZPcHRpb24DU1VJDFN0YWtlU3Vic2lkeRBTeXN0ZW1QYXJhbWV0ZXJzD1Rva2VuQWxsb2NhdGlvbhlUb2tlbkRpc3RyaWJ1dGlvblNjaGVkdWxlCVR4Q29udGV4dANVSUQJVmFsaWRhdG9yCGFjdGl2YXRlE2FjdGl2YXRlX3ZhbGlkYXRvcnMPYWxsb2NhdGVfdG9rZW5zC2FsbG9jYXRpb25zC2Ftb3VudF9taXN0B2JhbGFuY2UYY2hhaW5fc3RhcnRfdGltZXN0YW1wX21zBGNvaW4PY29tbWlzc2lvbl9yYXRlBmNyZWF0ZRhjcmVhdGVfc3lzdGVtX3BhcmFtZXRlcnMLZGVzY3JpcHRpb24MZGVzdHJveV9zb21lDGRlc3Ryb3lfemVybwVlcG9jaBFlcG9jaF9kdXJhdGlvbl9tcwxmcm9tX2JhbGFuY2UJZ2FzX3ByaWNlB2dlbmVzaXMRZ2V0X3ZhbGlkYXRvcl9tdXQJaW1hZ2VfdXJsFmlzX2R1cGxpY2F0ZV92YWxpZGF0b3IIaXNfZW1wdHkHaXNfc29tZRNtYXhfdmFsaWRhdG9yX2NvdW50G21pbl92YWxpZGF0b3Jfam9pbmluZ19zdGFrZQRuYW1lD25ldHdvcmtfYWRkcmVzcxJuZXR3b3JrX3B1YmxpY19rZXkDbmV3Bm9iamVjdAZvcHRpb24LcDJwX2FkZHJlc3MPcHJpbWFyeV9hZGRyZXNzC3Byb2plY3RfdXJsE3Byb29mX29mX3Bvc3Nlc3Npb24TcHJvdG9jb2xfcHVibGljX2tleRBwcm90b2NvbF92ZXJzaW9uEXJlY2lwaWVudF9hZGRyZXNzHHJlcXVlc3RfYWRkX3N0YWtlX2F0X2dlbmVzaXMFc3BsaXQNc3Rha2Vfc3Vic2lkeRtzdGFrZV9zdWJzaWR5X2RlY3JlYXNlX3JhdGUXc3Rha2Vfc3Vic2lkeV9mdW5kX21pc3Qpc3Rha2Vfc3Vic2lkeV9pbml0aWFsX2Rpc3RyaWJ1dGlvbl9hbW91bnQbc3Rha2Vfc3Vic2lkeV9wZXJpb2RfbGVuZ3RoGXN0YWtlX3N1YnNpZHlfc3RhcnRfZXBvY2gVc3Rha2VkX3dpdGhfdmFsaWRhdG9yA3N1aQtzdWlfYWRkcmVzcwpzdWlfc3lzdGVtFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIIdHJhbnNmZXIKdHhfY29udGV4dAl2YWxpZGF0b3IgdmFsaWRhdG9yX2xvd19zdGFrZV9ncmFjZV9wZXJpb2QddmFsaWRhdG9yX2xvd19zdGFrZV90aHJlc2hvbGQNdmFsaWRhdG9yX3NldCJ2YWxpZGF0b3JfdmVyeV9sb3dfc3Rha2VfdGhyZXNob2xkBnZlY3Rvcg53b3JrZXJfYWRkcmVzcxF3b3JrZXJfcHVibGljX2tleQR6ZXJvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAIPJwoCGAoCIQoCLwoCPgUeAxUDMQoCMAoCKQoCSgoCKAoCLQoCLgoCSQoCAQIMMgMTAxwDOwM5AzoDNw0lAyYDRQNHA0QDAgICOAMQCggDAwIDMwURAzwLBAEFAAAAAASTAQoFLhELBgAAAAAAAAAAIQQHBQsLBQEGAAAAAAAAAAAnCwQTAgwGDBYNAQsWOAAMGDgBDBdACgAAAAAAAAAADBwOA0ELDAgGAAAAAAAAAAAMCwoLCggjBFkFIQ4DCgtCCxQTAAwdDBEMEAwODB4MDwwTDBQMBwwKDBkMEgwMDAkMDQsZCxQLDwseCxMLDQsJCwwLEgsOCxALEQsdCwoLBwoFERAMGw4cDhsREyAETQVRCwUBBgIAAAAAAAAAJw0cCxtECgsLBgEAAAAAAAAAFgwLBRwLAQsGDRwKBREBDRwRAg4CEAAUDgIQARQOAhACFA4CEAMUDgIQBBQOAhAFFA4CEAYUCgURDgwaCxgOAhAHFA4CEAgUDgIQCRQKBREMDBULAAscCxcOAhAKFA4CEAsUCxoLFQsFEQ0CAQAAABQsDgE4AiAEIwUFDQFFFRMDDAcMBQwGDQALBTgADAQOBzgDBB0LBzgEDAgKAgsIERILBAsGCgMREQUiCwQKAzgFCwYRCgUACwIBCwMBCwFGFQAAAAAAAAAACwA4BgICAAAAIRgKAC5BCgwBBgAAAAAAAAAADAIKAgoBIwQVBQsKAAoCQwoGAAAAAAAAAAARDwsCBgEAAAAAAAAAFgwCBQYLAAECAQIBAwEHAQgBCQEKAQsBBAEFAQYBAAEBAAl2YWxpZGF0b3KfPKEc6wsGAAAADAEAHwIfSANntwQEngUmBcQF7gMHsgnJEwj7HGAG2x2WAQrxHpwBDI0gjBsNmTs8D9U7DQCGAQEUARcBSQFnAhUCFgIiAkcCaAJvAoMBAGUAiAEADgQAAA0EAAAIAwAACwMAAQkHAAMDBwEAAAQJBwAFAAwABgEEAQABCAIHAAkFAgAKCgIACwwHAAwEBwAMBggADAcMAA0PAgAANwABAAA1AgMAABoEBQAAEAQFAAASBgUAAFYHBQAAVwcFAABaCAUAAFkJBQAAXgkFAABYBAUAAF0EBQAAHQoFAABSCwUAAC4MDQAAMAwOAABpDA8AADEMEAAAHgwQAAApDBEAAFMMEQAAMwwQAABKDBAAAE8MEAAAjgEMEAAAVQwSAABUDBIAADQMEgAAjwEMEgAAPQwTAAA/DBMAAEAMEwAARAwTAABCDBQAAEEMFAAAPgwUAABFDBQAAEgMFQAAOwwWAABuDBYAAGIMFgAAbQwWAACNAQwWAABfBAUAAEsMFgAATAwWAAAmDBYAABkMFgAAThcYAABmDBkAACoaDQAALBsNAQAAKxwNAQAAOQsFAAB6HQUAAHgdBQAAeR0FAACCAR0FAAB7HQUAAHEdBQAAfR0FAABzHQUAAH4dBQAAdB0FAACAAR0FAAB2HQUAAH8eBQAAdR4FAAB8HQUAAHIdBQAAgQEdBQAAdx0FAAAfBgUAAIQBDgUAAIUBHwUAADYgAwABZx8mAAJsPh8BAAMYQD4BAAMkQzMBAAMtQA0BAAMvQA0BAANGBSIBAANgMyIBAAQlJiMABTUoKQAGiwEtFgEAByAzBQEDCCg+GQEICiEuFgAKXC4PAAs4HycADBEqBQAMGyoFAAwcOgUADC4wDQAMNSg9AAxLMBYADEwwFgAMTjwYAAxRMQUADFI7BQAMVi8FAAxaNhYADGE1FgAMYzUWAAxqMBYADTlCGQANjAE4OQBSH1IjVixXMlc3WD00IzQfMyMzH1AzTjNTI1MfUSNPI1EfTx9NAQ4FCgIKAgoCCgIIBggGCAwIDAgGCAYIBggGCAcBCAAQBQoCCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgMDBwgLAQgBAgcIAQMAAQcIAQQHCAELCAEICgUHCAsDBwgBCA4HCAsDBwgBCBADAgcIAQsIAQgKAgcIAQcICwEGCAEBAQEGCAABBQEGCAYBBggMAQYKAgEGCwUBCAYBBgsFAQoCAQYICQEDAgYIAQMBCA0BCAkCBggBBggBAgYLBQEJAAYJAAIGCwUBCQAGCwUBCQACBwgBCgIDBwgBCgIKAgEKAgQIAAMDBwgLFgUIBggGCAYIBgsFAQoCCwUBCgILBQEKAgsFAQoCCwUBCAYLBQEIBgoCCwUBCAYLBQEIBggHCgIKAgoCCAYIBggMCAwBCwUBCQABCAYIAQEBAQEBAQgAAQIBCAQBCAwBBwgLAQgHAgcIDwMCAwMBCAoBBgsIAQkAAQYICwUHCA8LCAEICgUDBwgLAQYIDwEHCA8BCAIBCQAEAwMDAwEGCA4DBwgPCA4HCAsBCAMBBggQAQYFAgcIDwsIAQgKAgcIDwcICwIGCA8DAQgPAQYJABsBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBBgsFAQkAAgEBAgUHCAsBBwsFAQkAAwgJCA8FA0JhZwdCYWxhbmNlAklEBk9wdGlvbhVQb29sVG9rZW5FeGNoYW5nZVJhdGUDU1VJCVN0YWtlZFN1aQtTdGFraW5nUG9vbBNTdGFraW5nUmVxdWVzdEV2ZW50BlN0cmluZwlUeENvbnRleHQVVW5zdGFraW5nUmVxdWVzdEV2ZW50A1VybAlWYWxpZGF0b3IRVmFsaWRhdG9yTWV0YWRhdGEVVmFsaWRhdG9yT3BlcmF0aW9uQ2FwCGFjdGl2YXRlFWFjdGl2YXRlX3N0YWtpbmdfcG9vbBphZGp1c3Rfc3Rha2VfYW5kX2dhc19wcmljZQZhbW91bnQFYXNjaWkDYmFnB2JhbGFuY2UDYmNzBmJvcnJvdw9jb21taXNzaW9uX3JhdGUKZGVhY3RpdmF0ZRdkZWFjdGl2YXRlX3N0YWtpbmdfcG9vbA9kZXBvc2l0X3Jld2FyZHMVZGVwb3NpdF9zdGFrZV9yZXdhcmRzC2Rlc2NyaXB0aW9uGmVmZmVjdHVhdGVfc3RhZ2VkX21ldGFkYXRhBGVtaXQFZXBvY2gFZXZlbnQMZXh0cmFfZmllbGRzB2V4dHJhY3QKZnJvbV9hc2NpaQlnYXNfcHJpY2UHZ2VuZXNpcwJpZAlpbWFnZV91cmwMaXNfZHVwbGljYXRlDWlzX2VxdWFsX3NvbWUXaXNfZXF1YWxfc29tZV9hbmRfdmFsdWUHaXNfbm9uZQxpc19wcmVhY3RpdmUHaXNfc29tZQhtZXRhZGF0YQRuYW1lC25ldF9hZGRyZXNzD25ldHdvcmtfYWRkcmVzcxRuZXR3b3JrX3B1YmtleV9ieXRlcwNuZXcRbmV3X2Zyb21fbWV0YWRhdGEMbmV3X21ldGFkYXRhFW5ld191bnNhZmVfZnJvbV9ieXRlczNuZXdfdW52ZXJpZmllZF92YWxpZGF0b3Jfb3BlcmF0aW9uX2NhcF9hbmRfdHJhbnNmZXIabmV4dF9lcG9jaF9jb21taXNzaW9uX3JhdGUUbmV4dF9lcG9jaF9nYXNfcHJpY2UWbmV4dF9lcG9jaF9uZXRfYWRkcmVzcxpuZXh0X2Vwb2NoX25ldHdvcmtfYWRkcmVzcx9uZXh0X2Vwb2NoX25ldHdvcmtfcHVia2V5X2J5dGVzFm5leHRfZXBvY2hfcDJwX2FkZHJlc3MabmV4dF9lcG9jaF9wcmltYXJ5X2FkZHJlc3MebmV4dF9lcG9jaF9wcm9vZl9vZl9wb3NzZXNzaW9uIG5leHRfZXBvY2hfcHJvdG9jb2xfcHVia2V5X2J5dGVzEG5leHRfZXBvY2hfc3Rha2UZbmV4dF9lcG9jaF93b3JrZXJfYWRkcmVzcx5uZXh0X2Vwb2NoX3dvcmtlcl9wdWJrZXlfYnl0ZXMEbm9uZQZvYmplY3QQb3BlcmF0aW9uX2NhcF9pZAZvcHRpb24LcDJwX2FkZHJlc3MUcGVuZGluZ19zdGFrZV9hbW91bnQdcGVuZGluZ19zdGFrZV93aXRoZHJhd19hbW91bnQHcG9vbF9pZCFwb29sX3Rva2VuX2V4Y2hhbmdlX3JhdGVfYXRfZXBvY2gPcHJpbWFyeV9hZGRyZXNzEHByaW5jaXBhbF9hbW91bnQVcHJvY2Vzc19wZW5kaW5nX3N0YWtlJHByb2Nlc3NfcGVuZGluZ19zdGFrZXNfYW5kX3dpdGhkcmF3cwtwcm9qZWN0X3VybBNwcm9vZl9vZl9wb3NzZXNzaW9uFXByb3RvY29sX3B1YmtleV9ieXRlcxFyZXF1ZXN0X2FkZF9zdGFrZRxyZXF1ZXN0X2FkZF9zdGFrZV9hdF9nZW5lc2lzG3JlcXVlc3Rfc2V0X2NvbW1pc3Npb25fcmF0ZRVyZXF1ZXN0X3NldF9nYXNfcHJpY2UWcmVxdWVzdF93aXRoZHJhd19zdGFrZQ1yZXdhcmRfYW1vdW50BnNlbmRlch1zZXRfY2FuZGlkYXRlX2NvbW1pc3Npb25fcmF0ZRdzZXRfY2FuZGlkYXRlX2dhc19wcmljZRBzZXRfdm90aW5nX3Bvd2VyBHNvbWUWc3Rha2VfYWN0aXZhdGlvbl9lcG9jaAxzdGFrZV9hbW91bnQRc3Rha2VkX3N1aV9hbW91bnQOc3Rha2VyX2FkZHJlc3MMc3Rha2luZ19wb29sD3N0YWtpbmdfcG9vbF9pZAZzdHJpbmcDc3VpC3N1aV9hZGRyZXNzC3N1aV9iYWxhbmNlFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIIdG9fYnl0ZXMLdG90YWxfc3Rha2USdG90YWxfc3Rha2VfYW1vdW50CnR4X2NvbnRleHQPdW5zdGFraW5nX2Vwb2NoIHVwZGF0ZV9jYW5kaWRhdGVfbmV0d29ya19hZGRyZXNzH3VwZGF0ZV9jYW5kaWRhdGVfbmV0d29ya19wdWJrZXkcdXBkYXRlX2NhbmRpZGF0ZV9wMnBfYWRkcmVzcyB1cGRhdGVfY2FuZGlkYXRlX3ByaW1hcnlfYWRkcmVzcyB1cGRhdGVfY2FuZGlkYXRlX3Byb3RvY29sX3B1YmtleR91cGRhdGVfY2FuZGlkYXRlX3dvcmtlcl9hZGRyZXNzHnVwZGF0ZV9jYW5kaWRhdGVfd29ya2VyX3B1YmtleRJ1cGRhdGVfZGVzY3JpcHRpb24QdXBkYXRlX2ltYWdlX3VybAt1cGRhdGVfbmFtZSF1cGRhdGVfbmV4dF9lcG9jaF9uZXR3b3JrX2FkZHJlc3MgdXBkYXRlX25leHRfZXBvY2hfbmV0d29ya19wdWJrZXkddXBkYXRlX25leHRfZXBvY2hfcDJwX2FkZHJlc3MhdXBkYXRlX25leHRfZXBvY2hfcHJpbWFyeV9hZGRyZXNzIXVwZGF0ZV9uZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleSB1cGRhdGVfbmV4dF9lcG9jaF93b3JrZXJfYWRkcmVzcx91cGRhdGVfbmV4dF9lcG9jaF93b3JrZXJfcHVia2V5EnVwZGF0ZV9wcm9qZWN0X3VybAN1cmwRdmFsaWRhdGVfbWV0YWRhdGEVdmFsaWRhdGVfbWV0YWRhdGFfYmNzCXZhbGlkYXRvchF2YWxpZGF0b3JfYWRkcmVzcw12YWxpZGF0b3JfY2FwDXZhbGlkYXRvcl9zZXQRdmFsaWRhdG9yX3dyYXBwZXIFdmFsdWUedmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzDHZvdGluZ19wb3dlcg53b3JrZXJfYWRkcmVzcxN3b3JrZXJfcHVia2V5X2J5dGVzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMICgAAAAAAAAADCGQAAAAAAAAAAwhlAAAAAAAAAAMIECcAAAAAAAADCAABAAAAAAAAAAIWaQVVCgI0CgKPAQoCVAoCMQgGHggGKQgMUwgMMggGSggGTwgGjgEIBkILBQEKAkELBQEKAj4LBQEKAkULBQEKAjwLBQEIBj8LBQEIBkALBQEIBkQLBQEIBiMIBwECCjAIAI0BA0gICSYDZQgPGQNDAzsDOgMjCAcCAgVNCAmHAQVkBSEDEwMDAgdNCAmHAQVkBWEDcANQA1sDAAMAACFECwAMDgsBDBkLAgwdCwMMHgsEDB8LBQwgCwYMIQsHDCILCAwjCwkMDwsKDBALCwwRCwwMEjgADBM4AAwUOAAMFTgADBY4AQwXOAEMGDgBDBo4AQwbCw0MHAsOCxkLHQseCx8LIAshCyILIwsPCxALEQsSCxMLFgsUCxULFwsYCxoLGwscEgACAQMAACSAAQ4JQSUHDiUECw4KQSUHDiUMEAUNCQwQCxAEFQ4LQSUHDiUMEQUXCQwRCxEEHw4MQSUHDiUMEgUhCQwSCxIEKQ4FQSUHDiUMEwUrCQwTCxMEMw4GQSUHDiUMFAU1CQwUCxQEPQ4HQSUHDiUMFQU/CQwVCxUERw4IQSUHDiUMFgVJCQwWCxYETAVQCw8BBwknCg4HDSUEVQVZCw8BBwgnCwALAQsCCwMLBAsFEUwRVAsGEUwRVAsHEVsLCBFbCwkRTBFUCwoRTBFUCwsRTBFUCwwRTBFUCg8RVREADBcOFxFJCxcLDQsOCw8RSwICAwAABQULAA8ACwERXQIDAwAABQULAA8ACwERXAIEAwAABQ0KABABFAoADwIVCgAQAxQLAA8EFQIFAwAAKzkOATgCDAQKBAYAAAAAAAAAACQECAUOCwABCwMBBgAAAAAAAAAAJwoDLhFZBgEAAAAAAAAAFgwFCgAPAAsBCgILBQoDEWYKABAAEV8EIgoADwARZAoAEAUUCgQWCgAPBRUKAC4RMQsAEAYQBxQLAgsDLhFZCwQSAjgDAgYDAAAWLgoDLhFZBgAAAAAAAAAAIQQHBQ0LAAELAwEGAAAAAAAAAAAnDgE4AgwECgQGAAAAAAAAAAAkBBUFGwsAAQsDAQYAAAAAAAAAACcKAA8ACwELAgYAAAAAAAAAAAsDEWYKAA8AEWQKABAFFAsEFgsADwUVAgcDAAA0Kw4BEWkMAw4BEWgMBQoADwALAQoCEWcMBgoGCgMXDAQKABAFFAsGFwoADwUVCgAuETELABAGEAcUCgIuEVoLBQsCLhFZCwMLBBIDOAQCCAMAAAUTDgERbBQKABAGEAcUIQQKBQ4LAAEHDCcLAgsADwEVAgkDAAAFIAoALhEOBAUFCQsAAQcKJw4BEWwUCgAQBhAHFCEEEwUXCwABBwwnCgIKAA8BFQsCCwAPAhUCCgMAAAUOCgEHDSUEBQUJCwABBwgnCwELAA8DFQILAwAABRcKAC4RDgQFBQkLAAEHCicKAQcNJQQOBRILAAEHCCcLAQsADwQVAgwDAAAFDgoAEAUUDgE4AhYKAA8FFQsADwALARFeAg0DAAAFEAoADwALARFlCgAuESgLABAFFCEEDQUPBgAAAAAAAAAAJwIOAQAABQQLABAAEV8CDwEAAAUDCwAQBgIQAQAABQULABAGEAcUAhEBAAAFBAsAEAYQCAISAQAABQQLABAGEAkCEwEAAAUECwAQBhAKAhQBAAAFBAsAEAYQCwIVAQAABQQLABAGEAwCFgEAAAUECwAQBhANAhcBAAAFBAsAEAYQDgIYAQAABQQLABAGEA8CGQEAAAUECwAQBhAQAhoBAAAFBAsAEAYQEQIbAQAABQQLABAGEBICHAEAAAUECwAQBhATAh0BAAAFBAsAEAYQFAIeAQAABQQLABAGEBUCHwEAAAUECwAQBhAWAiABAAAFBAsAEAYQFwIhAQAABQQLABAGEBgCIgEAAAUECwAQBhAZAiMBAAAFBAsAEAYQGgIkAQAABQQLABAGEBsCJQEAAAUDCwAQHAImAQAABQQLABABFAInAQAABQUoCwAQABFqAigBAAAFBAsAEAARagIpAQAABQMLABEoAioBAAAFBAsAEB0UAisDAAAFBQsBCwAPHRUCLAEAAAUECwAQABFhAi0BAAAFBAsAEAARYgIuAQAABQQLABACFAIvAQAABQQLABAEFAIwAQAABQULABAACwERYwIxAQAABQQLABAAOAUCMgEAAD/5AgoAEAYQBxQKARAGEAcUIQQNCAwCBRcKABAGEAgUCgEQBhAIFCEMAgsCBBwIDA0FJgoAEAYQEBQKARAGEBAUIQwNCw0EKwgMFgU1CgAQBhASFAoBEAYQEhQhDBYLFgQ6CAwXBUQKABAGEBIUCgEQBhATFCEMFwsXBEkIDBgFUwoAEAYQExQKARAGEBMUIQwYCxgEWAgMGQViCgAQBhATFAoBEAYQEhQhDBkLGQRnCAwaBW8KABAGEBQKARAGEBQ4BgwaCxoEdAgMGwV8CgAQBhAVCgEQBhAVOAYMGwsbBIEBCAwcBYkBCgAQBhAYCgEQBhAYOAcMHAscBI4BCAwDBZYBCgAQBhAaCgEQBhAaOAcMAwsDBJsBCAwEBaMBCgAQBhAaCgEQBhAbOAcMBAsEBKgBCAwFBbABCgAQBhAbCgEQBhAbOAcMBQsFBLUBCAwGBb0BCgAQBhAbCgEQBhAaOAcMBgsGBMIBCAwHBcoBCgAQBhAUCgEQBhAMOAgMBwsHBM8BCAwIBdcBCgAQBhAVCgEQBhANOAgMCAsIBNwBCAwJBeQBCgAQBhAYCgEQBhAQOAkMCQsJBOkBCAwKBfEBCgAQBhAaCgEQBhASOAkMCgsKBPYBCAwLBf4BCgAQBhAaCgEQBhATOAkMCwsLBIMCCAwMBYsCCgAQBhAbCgEQBhATOAkMDAsMBJACCAwOBZgCCgAQBhAbCgEQBhASOAkMDgsOBJ0CCAwPBaUCCgEQBhAUCgAQBhAMOAgMDwsPBKoCCAwQBbICCgEQBhAVCgAQBhANOAgMEAsQBLcCCAwRBb8CCgEQBhAYCgAQBhAQOAkMEQsRBMQCCAwSBcwCCgEQBhAaCgAQBhASOAkMEgsSBNECCAwTBdkCCgEQBhAaCgAQBhATOAkMEwsTBN4CCAwUBeYCCgEQBhAbCgAQBhATOAkMFAsUBO8CCwABCwEBCAwVBfcCCwEQBhAbCwAQBhASOAkMFQsVAjMAAAANEQoAOAoECgsBAQsAAQkMAgUPCwA4CwsBIQwCCwICNAAAAEEaCgA4CgQGCAwCBQkKATgKDAILAgQSCwEBCwABCQwDBRgLADgLCwE4CyEMAwsDAjUDAAAPGQoBLhFaDAIKAgoAEAYQBxQhBAwFEgsAAQsBAQcLJwsCCwERawsADxwVAjYDAAAFEg4BQSUHDiUEBgUKCwABBwknCwERTBFUCwAPBg8IFQI3AwAABRIOAUElBw4lBAYFCgsAAQcJJwsBEUwRVAsADwYPCRUCOAMAAAURDgFBJQcOJQQGBQoLAAEHCScLARFbCwAPBg8KFQI5AwAABREOAUElBw4lBAYFCgsAAQcJJwsBEVsLAA8GDwsVAjoDAAAFFg4BQSUHDiUEBgUKCwABBwknCwERTBFUOAwKAA8GDxQVCwAQBhFJAjsDAAAFHgoALhEOBAUFCQsAAQcKJw4BQSUHDiUEDwUTCwABBwknCwERTBFUCgAPBg8MFQsAEAYRSQI8AwAABRYOAUElBw4lBAYFCgsAAQcJJwsBEUwRVDgMCgAPBg8VFQsAEAYRSQI9AwAABR4KAC4RDgQFBQkLAAEHCicOAUElBw4lBA8FEwsAAQcJJwsBEUwRVAoADwYPDRULABAGEUkCPgMAAAUWDgFBJQcOJQQGBQoLAAEHCScLARFMEVQ4DAoADwYPFhULABAGEUkCPwMAAAUeCgAuEQ4EBQUJCwABBwonDgFBJQcOJQQPBRMLAAEHCScLARFMEVQKAA8GDw4VCwAQBhFJAkADAAAFFg4BQSUHDiUEBgUKCwABBwknCwERTBFUOAwKAA8GDxcVCwAQBhFJAkEDAAAFHgoALhEOBAUFCQsAAQcKJw4BQSUHDiUEDwUTCwABBwknCwERTBFUCgAPBg8PFQsAEAYRSQJCAwAABRALATgNCgAPBg8YFQsCOA0KAA8GDxkVCwAQBhFJAkMDAAAFFwoALhEOBAUFCQsAAQcKJwsBCgAPBg8QFQsCCgAPBg8RFQsAEAYRSQJEAwAABQoLATgNCgAPBg8aFQsAEAYRSQJFAwAABRIKAC4RDgQFBQkLAAEHCicLAQoADwYPEhULABAGEUkCRgMAAAUKCwE4DQoADwYPGxULABAGEUkCRwMAAAUSCgAuEQ4EBQUJCwABBwonCwEKAA8GDxMVCwAQBhFJAkgDAAAFjwEKAC4RHTgOBBIKAA8GDxQ4DwoADwYPDBU4AQoADwYPFBUKAC4RHjgOBCQKAA8GDxU4DwoADwYPDRU4AQoADwYPFRUKAC4RHzgOBDYKAA8GDxY4DwoADwYPDhU4AQoADwYPFhUKAC4RIDgOBEgKAA8GDxc4DwoADwYPDxU4AQoADwYPFxUKAC4RITgQBGcKAA8GDxg4EQoADwYPEBU4AAoADwYPGBUKAA8GDxk4EQoADwYPERU4AAoADwYPGRUKAC4RIzgQBHkKAA8GDxo4EQoADwYPEhU4AAoADwYPGhUKAC4RJDgQBIwBCgAPBg8bOBEKAA8GDxMVOAALAA8GDxsVBY4BCwABAkkBAAAFBAsAOBIRSgJKAQIASwAAAEQYDgAQBxQMBgoDEWAMBQsGCgMRawwECwAGAAAAAAAAAAALBAoBCwUKAgYAAAAAAAAAAAsBCwILAxFVEgECAQQBBwEDAQgBBQEGAQAAAAAFAAYABwAIAAkACgALAAwAAQAEAAIAAwARABIAEwAUAA0ADgAPABABAgEBACcAawCJAQCKAQCNAQAKc3VpX3N5c3RlbdoboRzrCwYAAAAMAQAcAhw6A1aQAwTmAwYF7AO9AwepB7EMCNoTYAa6FCIK3BQIDOQUtQYNmRsED50bAgAvARwCEAISAhQCGwIuAjICMwAsAC0AMABHAEgABggAAQIHAQAAAgAEAQABAwEMAQABBQoEAAYDAgAICQIACQQEAAoFCAALBwQACwgEAAwMBAANCwwAABMAAQAAIQIBAAAjAwEAACADAQAAIgMBAAAlBAEAACoEAQAAJAUBAAApBQEAAB4GAQAAHwcBAAAmCAEAAB0JAQAANAkBAAAnAwEAAD4KAQAAPAoBAAA9CgEAAEYKAQAAPwoBAAA1CgEAAEEKAQAANwoBAABCCgEAADgKAQAARAoBAAA6CgEAAEMLAQAAOQsBAABFCgEAADsKAQAAQAoBAAA2CgEAAA4MDQAADw4BAAAZDxAAABoPEQAAGA8RAAQNFwECBwQEESkqAgcEBysZAQEICCgkJQALDiYNAAsPJwEACxMTFAALFgEVAAsdIQEACx4eAQALHx8BAAsgGwEACyEaAQALIhsBAAsjGwEACyQdAQALJRwBAAsmIAEACycbAQALKR0BAAsqHAEACzEQFQALNCEBAAs1IgEACzYiAQALNyIBAAs4IgEACzkjAQALOiIBAAs7IgEACzwiAQALPSIBAAs+IgEACz8iAQALQCIBAAtBIgEAC0IiAQALQyMBAAtEIgEAC0UiAQALRiIBACYWKBgnFggIBAoICwsCAQgFAwMICggHBwgGABAHCAAKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIDAwcIBgIHCAAHCAYDBwgABggMAwMHCAADBwgGBAcIAAsDAQgFBQcIBgUHCAAKCwMBCAULAQEDBQcIBgMHCAAICAcIBgMHCAAGCAwFAwcIAAoCBggGBAcIAAoCCgIGCAYLCwIBCAULAgEIBQcIAAMDAwMDAwMHCAYBCwIBCAUICwIBCAULAgEIBQcIAAMDAwMHCAYBBwgAAQYICQEHCAkDCAAICQMHCggLCwIBCAUDAwgKCAcHCAYBCAkBAwIDCAkDBwgECQAJAQEIAAEJABAHCAkKAgoCCgIKAgoCCgIKAgoCCgIKAgoCCgIDAwcIBgIHCAkHCAYDBwgJBggMAwMHCAkDBwgGBAcICQsDAQgFBQcIBgUHCAkKCwMBCAULAQEDBQcIBgMHCAkICAcIBgMHCAkGCAwFAwcICQoCBggGBAcICQoCCgIGCAYBBggGAQULBwgJAwMLAgEIBQsCAQgFAwMDAwMHCAYIBwgJAwMLAgEIBQsCAQgFAwMHCAYCBwgJAwIHCAQJAAEHCQEHQmFsYW5jZQRDb2luBk9wdGlvbgNTVUkMU3Rha2VTdWJzaWR5CVN0YWtlZFN1aQ5TdWlTeXN0ZW1TdGF0ZRNTdWlTeXN0ZW1TdGF0ZUlubmVyEFN5c3RlbVBhcmFtZXRlcnMJVHhDb250ZXh0A1VJRB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwCVZhbGlkYXRvcgNhZGQNYWR2YW5jZV9lcG9jaBdhZHZhbmNlX2Vwb2NoX3NhZmVfbW9kZQdiYWxhbmNlCmJvcnJvd19tdXQEY29pbgZjcmVhdGUNZHluYW1pY19maWVsZAdnZW5lc2lzHGdlbmVzaXNfc3lzdGVtX3N0YXRlX3ZlcnNpb24CaWQYbG9hZF9pbm5lcl9tYXliZV91cGdyYWRlEWxvYWRfc3lzdGVtX3N0YXRlFWxvYWRfc3lzdGVtX3N0YXRlX211dAZvYmplY3QGb3B0aW9uEHJlcG9ydF92YWxpZGF0b3IRcmVxdWVzdF9hZGRfc3Rha2UacmVxdWVzdF9hZGRfc3Rha2VfbXVsX2NvaW4VcmVxdWVzdF9hZGRfdmFsaWRhdG9yH3JlcXVlc3RfYWRkX3ZhbGlkYXRvcl9jYW5kaWRhdGUYcmVxdWVzdF9yZW1vdmVfdmFsaWRhdG9yInJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvcl9jYW5kaWRhdGUbcmVxdWVzdF9zZXRfY29tbWlzc2lvbl9yYXRlFXJlcXVlc3Rfc2V0X2dhc19wcmljZRZyZXF1ZXN0X3dpdGhkcmF3X3N0YWtlFHJvdGF0ZV9vcGVyYXRpb25fY2FwBnNlbmRlcidzZXRfY2FuZGlkYXRlX3ZhbGlkYXRvcl9jb21taXNzaW9uX3JhdGUhc2V0X2NhbmRpZGF0ZV92YWxpZGF0b3JfZ2FzX3ByaWNlDHNoYXJlX29iamVjdA1zdGFrZV9zdWJzaWR5DHN0YWtpbmdfcG9vbANzdWkKc3VpX3N5c3RlbRZzdWlfc3lzdGVtX3N0YXRlX2lubmVyFHN5c3RlbV9zdGF0ZV92ZXJzaW9uCHRyYW5zZmVyCnR4X2NvbnRleHQVdW5kb19yZXBvcnRfdmFsaWRhdG9yKnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX25ldHdvcmtfYWRkcmVzcyl1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9uZXR3b3JrX3B1YmtleSZ1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wMnBfYWRkcmVzcyp1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wcmltYXJ5X2FkZHJlc3MqdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcHJvdG9jb2xfcHVia2V5KXVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3dvcmtlcl9hZGRyZXNzKHVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3dvcmtlcl9wdWJrZXkcdXBkYXRlX3ZhbGlkYXRvcl9kZXNjcmlwdGlvbhp1cGRhdGVfdmFsaWRhdG9yX2ltYWdlX3VybBV1cGRhdGVfdmFsaWRhdG9yX25hbWUrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX25ldHdvcmtfYWRkcmVzcyp1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfbmV0d29ya19wdWJrZXkndXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3AycF9hZGRyZXNzK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wcmltYXJ5X2FkZHJlc3MrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleSp1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MpdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3dvcmtlcl9wdWJrZXkcdXBkYXRlX3ZhbGlkYXRvcl9wcm9qZWN0X3VybAl2YWxpZGF0b3INdmFsaWRhdG9yX2NhcAd2ZXJzaW9uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAhcIBEkDAAMAABIXCwELAgsDCwQLBQsGCwcRLAwJES0MCgsACgoSAAwIDQgPAAsKCwk4AAsIOAECAQEEAAETCwARJAsBCwILAwsECwULBgsHCwgLCQsKCwsLDAsNCw4LDxEyAgIBBAABBQsAESQLARE0AgMBBAABBQsAESQLARExAgQBBAABBQsAESQLAREzAgUBBAABBgsAESQLAQsCETYCBgEEAAEGCwARJAsBCwIROgIHAQQAAQYLABEkCwELAhE1AggBBAABBgsAESQLAQsCETkCCQEEAAEHCwARJAsBCwILAxEvAgoBBAABCAsAESQLAQsCCwMLBBEwAgsBBAABBgsAESQLAQsCETcCDAEEAAEGCwARJAsBCwIRLgINAQQAAQYLABEkCwELAhE8Ag4BBAABBQsAESQLARE4Ag8BBAABBgsAESQLAQsCEUYCEAEEAAEGCwARJAsBCwIRRAIRAQQAAQYLABEkCwELAhFFAhIBBAABBgsAESQLAQsCEU4CEwEEAAEGCwARJAsBCwIRRwIUAQQAAQYLABEkCwELAhE9AhUBBAABBgsAESQLAQsCEUkCFgEEAAEGCwARJAsBCwIRPwIXAQQAAQYLABEkCwELAhFKAhgBBAABBgsAESQLAQsCEUACGQEEAAEGCwARJAsBCwIRTAIaAQQAAQYLABEkCwELAhFCAhsBBAABBwsAESQLAQsCCwMRSwIcAQQAAQcLABEkCwELAgsDEUECHQEEAAEGCwARJAsBCwIRTQIeAQQAAQYLABEkCwELAhFDAh8BBAABBgsAESQLAQsCEUgCIAEEAAEGCwARJAsBCwIRPgIhAAAAER0LAhEkDAsKCi4RKQcAIQQKBRALCwELCgEGAAAAAAAAAAAnCwsLAwsECwALAQsFCwYLBwsICwkLChEqAiIAAAARGgsCESQMCAoHLhEpBwAhBAoFEAsIAQsHAQYAAAAAAAAAACcLCAsDCwQLAAsBCwULBgsHESsCIwAAAAEECwARJS4CJAAAAAEDCwARJQIlAAAAKBYKABABFAwCCwAPAAoCOAIMAQoBLhE7CwIhBBAFFAsBAQYAAAAAAAAAACcLAQIAAAABABUADHN0YWtpbmdfcG9vbPMdoRzrCwYAAAAMAQAWAhY6A1CvAgT/AiYFpQPgAgeFBpAJCJUPYAb1D7QBCqkRQgzrEawLDZcdHA+zHQQASQEwAg8CEAITAisCLwJKAk0CTgJPAAgMAAAFBwAABwgAAQQHAQAAAgAMAAMBBAEAAQQCDAEAAQYDBwAGCwQABwYCAAgJDAIHAQQBCgoCAAAtAAEAAD8CAwAAQAQFAABUBgcAAFAICQAAGAoDAAA9CwMAADwMAwAAOwwDAABVDQkAAAwOAwAAQQQFAAAVDgMAAEwPBQAANhARAABIEAUAAEcQBQAAJg8SAAAkDxIAAEUTCAAARhMDAAAqFAMAACMVEgAAORYXAAAzDwUAADQPBQAAJxYSAAAeGAUAAB8YBQAAIgMXAAASFgMAARE0IwEAARwxAwEAASA2MwEDASU0EgEAASg0EgEAAS4DHQEAAUQzHQEAAi0AIAADKSgFAQADRTAfAQADUyIFAQADVgMfAQAEHSkqAQAFLC0FAAYXHAMABiEjEQEIBi0AHAAIDi4DAgcECBE3OAIHBAgUNxICBwQILQAbAgcECT4kAwEMCU4kAwEIChkmBQAKQyYnADMaJAUqHikeLgE1CCceKx40KzAaKB4gBSUFIgUjBSEFHwUyGjEaAQcICwEIAAUHCAALBQEICQUDBwgLAAMHCAAIAgcICwEDAgcIAAgCAgMLBQEICQEIAgELBQEICQIHCAALBQEICQIHCAAHCAsBBwgABAcIAAMDAwIHCAADAQYIAAEGCAIBCAcBAQMHCAIDBwgLAgcIAggCAgYIAgYIAgIGCAADAQgBAgYIAQMBCwoCAwgBAgMIAQELCgIJAAkBAQgIAQsDAQkAAQgJAQsFAQkAAQgEAggCAwEGCwUBCQABBgkAAgkABQYDCwUBCAkDCwUBCAkFAwEGCAsBBQIHCwUBCQALBQEJAAILBQEJAAcICwELBgEJAAELBgEICQMDCAELBQEICQIDAwMHCwoCCQAJAQkACQEFAwMIAQMDAgcLBQEJAAMCBwsDAQkACQADCwUBCAkFAwEJAAEGCwMBCQACBggCCwUBCAkCBgsDAQkACQACBgsKAgkACQEJAAEGCQEDAwgBAwNCYWcHQmFsYW5jZQRDb2luAklEBk9wdGlvbhVQb29sVG9rZW5FeGNoYW5nZVJhdGUDU1VJCVN0YWtlZFN1aQtTdGFraW5nUG9vbAVUYWJsZQlUeENvbnRleHQDVUlEFWFjdGl2YXRlX3N0YWtpbmdfcG9vbBBhY3RpdmF0aW9uX2Vwb2NoA2FkZANiYWcHYmFsYW5jZQZib3Jyb3cYY2hlY2tfYmFsYW5jZV9pbnZhcmlhbnRzBGNvaW4IY29udGFpbnMXZGVhY3RpdmF0ZV9zdGFraW5nX3Bvb2wSZGVhY3RpdmF0aW9uX2Vwb2NoBmRlbGV0ZQ9kZXBvc2l0X3Jld2FyZHMFZXBvY2gOZXhjaGFuZ2VfcmF0ZXMMZXh0cmFfZmllbGRzBGZpbGwMZnJvbV9iYWxhbmNlDmdldF9zdWlfYW1vdW50EGdldF90b2tlbl9hbW91bnQQZ2V0X3dpdGhfZGVmYXVsdAJpZBVpbml0aWFsX2V4Y2hhbmdlX3JhdGUZaXNfZXF1YWxfc3Rha2luZ19tZXRhZGF0YQtpc19pbmFjdGl2ZQdpc19ub25lDGlzX3ByZWFjdGl2ZRVpc19wcmVhY3RpdmVfYXRfZXBvY2gHaXNfc29tZQRqb2luD2pvaW5fc3Rha2VkX3N1aQRtYXRoA21pbgNuZXcEbm9uZQZvYmplY3QGb3B0aW9uG3BlbmRpbmdfcG9vbF90b2tlbl93aXRoZHJhdw1wZW5kaW5nX3N0YWtlFHBlbmRpbmdfc3Rha2VfYW1vdW50HXBlbmRpbmdfc3Rha2Vfd2l0aGRyYXdfYW1vdW50GnBlbmRpbmdfdG90YWxfc3VpX3dpdGhkcmF3B3Bvb2xfaWQRcG9vbF90b2tlbl9hbW91bnQScG9vbF90b2tlbl9iYWxhbmNlIXBvb2xfdG9rZW5fZXhjaGFuZ2VfcmF0ZV9hdF9lcG9jaAlwcmluY2lwYWwVcHJvY2Vzc19wZW5kaW5nX3N0YWtlHnByb2Nlc3NfcGVuZGluZ19zdGFrZV93aXRoZHJhdyRwcm9jZXNzX3BlbmRpbmdfc3Rha2VzX2FuZF93aXRoZHJhd3MPcHVibGljX3RyYW5zZmVyEXJlcXVlc3RfYWRkX3N0YWtlFnJlcXVlc3Rfd2l0aGRyYXdfc3Rha2UgcmVxdWVzdF93aXRoZHJhd19zdGFrZV9wcmVhY3RpdmUMcmV3YXJkc19wb29sBnNlbmRlcgRzb21lBXNwbGl0EHNwbGl0X3N0YWtlZF9zdWkWc3Rha2VfYWN0aXZhdGlvbl9lcG9jaBFzdGFrZWRfc3VpX2Ftb3VudAxzdGFraW5nX3Bvb2wDc3VpCnN1aV9hbW91bnQLc3VpX2JhbGFuY2UFdGFibGUIdHJhbnNmZXIKdHhfY29udGV4dBF1bndyYXBfc3Rha2VkX3N1aQl2YWxpZGF0b3INdmFsaWRhdG9yX3NldAV2YWx1ZRd3aXRoZHJhd19mcm9tX3ByaW5jaXBhbBB3aXRoZHJhd19yZXdhcmRzBHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCAAAAAAAAAAAAwgBAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAMIBQAAAAAAAAADCAYAAAAAAAAAAwgHAAAAAAAAAAMICAAAAAAAAAADCAkAAAAAAAAAAwgKAAAAAAAAAAMICwAAAAAAAAADCAwAAAAAAAAAAwgNAAAAAAAAAAMIDgAAAAAAAAADCA8AAAAAAAAAAwgQAAAAAAAAAAMIEQAAAAAAAAAAAgshCAgNCwMBAxYLAwEDTANCCwUBCAk4AxoLCgIDCAEyAzUDMQMbCAQBAgJLAzcDAgIEIQgINggHRwM6CwUBCAkAAwAAGRIKADgADAEKABEvOAE4AQYAAAAAAAAAADgCBgAAAAAAAAAACwEGAAAAAAAAAAAGAAAAAAAAAAAGAAAAAAAAAAALABEmEgACAQMAACEvDgE4AwwGCgAuERIgBAkFDwsAAQsEAQcKJwoGBgAAAAAAAAAAJAQUBRoLAAELBAEHEScLBBEvCgAuOAQLAwsBEgIMBQoAEAAUCwYWCwAPABULBQsCOAUCAgMAACU9CgALAREDDAQMAwoCLhE3DAcOBDgDDAUKAAoFCgMKAi4RNhEJDAYLBQ4GOAMWDAgKABABFAoIFgoADwEVCgAQAhQLAxYKAA8CFQoALhESBDALABEHBTILAAENBAsGOAYBCwQLAjgHCwc4CAsIAgMDAAAsHw4BEAMUCgAuOAQhBAkFDQsAAQcBJwsADgEQBBQMAi4LAhEXDAMLAREEDAQOAw4EOAMRHAsEAgQAAAAJCAsAEwIMAQEBES0LAQIFAwAAAw8KABAFFA4BOAMWCgAPBRULAA8GCwE4BgECBgMAAC0cCwEuETYGAQAAAAAAAAAWDAMKABEHCgARCAoADwcKAwoAEAUUCgAQCBQSATgJCwALAwwCLgsCER4CBwAAAAMdCgAQBRQKABABFBcKAA8FFQoAEAgUCgAQAhQXCgAPCBUGAAAAAAAAAAAKAA8BFQYAAAAAAAAAAAsADwIVAggDAAAXHwoAEAUUCgAQCBQSAQwBCgAQBRQKABAAFBYKAA8FFQ4BCgAQBRQRHAoADwgVBgAAAAAAAAAACwAPABUCCQAAAC8hCgALAwwELgsEERcMBg4GCwIRGwwICggKASYEFAsICwEXDAUFFgYAAAAAAAAAAAwFCwUKABAGOAMRLAwHCwAPBgsHOAoCCgMAAAMdCgAPBwoBER04CQoALhERBAoFDgsAAQcOJwoALhESIAQUBRgLAAEHECcLAA8JCwE4CwILAwAAMjsOARADFAoALjgEIQQJBQ8LAAELAgEHAScKAC4REQQUBRoLAAELAgEHDycKAi4RNwwECwERBAwDDgM4AwwFCgAQBRQKBRcKAA8FFQoAEAgUCgUXCwAPCBULAwsCOAcLBDgICwUCDAMAAAMQCgAuERIgBAYFCgsAAQcLJwsBOAwLAA8KFQINAQAAAwQLABAFFAIOAQAAAwQLABADFAIPAQAAAwQLABALOAMCEAEAAAMECwAQBBQCEQEAAAMECwAQCTgNAhIBAAADBAsAEAo4DgITAQAAAw4LAhEvCgAQAxQKABAEFAsADwsLATgKEgICFAEEAAMJCwALAQoCERMLAi4RNzgFAhUBBAA1GAoADgEMAi4LAhEWBAgFDAsAAQcMJwsBEwIMAwEBES0LAA8LCwM4BgECFgEAABIZCgAQAxQKARADFCEEEQsAEAQUCwEQBBQhDAIFFwsAAQsBAQkMAgsCAhcBAAAtLQoACgERGgQICwABER0CCgAQCgoBOA8LAREsDAMKABAJOBAUDAIKAwoCJgQpBRkKABAHCgM4EQQkCwAQBwsDOBIUAgsDBgEAAAAAAAAAFwwDBRQLAAERHQIYAQAAAwQLABAAFAIZAQAAAwQLABABFAIaAAAAEhEKABERBAgLAAEIDAIFDwsAEAk4EBQLASQMAgsCAhsAAAASIwoAEAwUBgAAAAAAAAAAIQQJCAwCBQ8KABANFAYAAAAAAAAAACEMAgsCBBULAAELAQIKABAMFDULATUYCwAQDRQ1GjQCHAAAABIjCgAQDBQGAAAAAAAAAAAhBAkIDAIFDwoAEA0UBgAAAAAAAAAAIQwCCwIEFQsAAQsBAgoAEA0UNQsBNRgLABAMFDUaNAIdAAAAAwQGAAAAAAAAAAAGAAAAAAAAAAASAQIeAAAAORYKAAsBERcMAw4DCgAQBRQRHAwECwAQCBQMAgsECwIhBBMFFQcJJwIABwAIAAkCAQICAAMABAAGAAUAAQACAgMBAAEBAFEAUgAMc3RvcmFnZV9mdW5ktQShHOsLBgAAAAsBAAYCBg4DFCwEQAgFSEkHkQGyAQjDAkAKgwMPDJIDaw39AwQPgQQCAAkBBAEKAAIEAAEABAEAAQIBAgAABgABAAADAgAAAA0DBAAADAMEAAEFCAQBAAEICQcBAAEOCgQBAAEPBQcBAAcGBAYFBgYGAQsBAQgCAQgABgcIAAsBAQgCCwEBCAILAQEIAgMDAQYIAAEDAAEIAgELAQEJAAIHCwEBCQALAQEJAAIHCwEBCQADAQYLAQEJAAdCYWxhbmNlA1NVSQtTdG9yYWdlRnVuZA1hZHZhbmNlX2Vwb2NoB2JhbGFuY2UEam9pbgNuZXcWbm9uX3JlZnVuZGFibGVfYmFsYW5jZQVzcGxpdAxzdG9yYWdlX2Z1bmQDc3VpFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXINdG90YWxfYmFsYW5jZRx0b3RhbF9vYmplY3Rfc3RvcmFnZV9yZWJhdGVzBXZhbHVlBHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAICDQsBAQgCBwsBAQgCAAMAAAUEOAALABIAAgEDAAAAHgoADwALAjgBAQoADwALAzgBAQoADwELATgBAQoADwELBTgCDAYKAA8ACwY4AQELAA8BCwQ4AgICAQAABQQLABABOAMCAwEAAAUICgAQATgDCwAQADgDFgIAAQAAAAsADHZvdGluZ19wb3dlcugMoRzrCwYAAAAMAQAIAggIAxBXBGcEBWuFAQfwAZgCCIgEYAboBEYKrgUHDLUF9wYNrAwCD64MAgAUARMCCAAQAAECAAMABAAADAABAAAFAgMAAA0EBQAABgYBAAACBwEAAA8IAQAAAwQBAAAOAQUAAAsBBQABBhEBAQABBxMUAQACBAsFAAIJCwUAAgoLBQADDBUBAAMNDgUAAxQOBQAJDQoNAQcKCAEAAgYKCAEDAgoIAAMBBgoIAQEDAgcKCAAIAAMHCggAAwMCBwoIAQoIAAQDCggAAwMBCAECAwMHAwgAAwoIAAMDAwEIAAEGCAEDAwMDBAMBAwMDBwoJAAkAAwcBAwMDAwMHCAABBgoJAAEBAgcIAQMMAwMDAwMDAwMDBggBBggBAwlWYWxpZGF0b3IPVm90aW5nUG93ZXJJbmZvE2FkanVzdF92b3RpbmdfcG93ZXIQY2hlY2tfaW52YXJpYW50cxNkaXZpZGVfYW5kX3JvdW5kX3VwFmluaXRfdm90aW5nX3Bvd2VyX2luZm8GaW5zZXJ0CGlzX2VtcHR5BG1hdGgDbWF4A21pbhBxdW9ydW1fdGhyZXNob2xkEHNldF92b3RpbmdfcG93ZXILdG90YWxfc3Rha2USdG90YWxfdm90aW5nX3Bvd2VyE3VwZGF0ZV92b3RpbmdfcG93ZXIJdmFsaWRhdG9yD3ZhbGlkYXRvcl9pbmRleA12YWxpZGF0b3Jfc2V0BnZlY3Rvcgx2b3RpbmdfcG93ZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDCBAnAAAAAAAAAwgLGgAAAAAAAAMI6AMAAAAAAAADCAEAAAAAAAAAAwgCAAAAAAAAAAMIAwAAAAAAAAADCAQAAAAAAAAAAAICEQMUAwADAAAJHQcABwIHAAoALkEKEQsRDBENDAQKAAoEDAEuCwERAQwDDAINAgsECwMRBAoACwIRBQsALhEGAgEAAAAMNwoAEQIMBwYAAAAAAAAAAAwCCgBBCgwEBgAAAAAAAAAADAZADQAAAAAAAAAADAUKAgoEIwQwBREKAAoCQgoRDzUHADUYCgc1GjQKARENDAgKAgoIEgAMAw0FCwMRAwsGCwgWDAYLAgYBAAAAAAAAABYMAgUMCwABCwUHAAsGFwICAAAADxwGAAAAAAAAAAAMAQoAQQoMAgYAAAAAAAAAAAwDCgEKAiMEGAUMCwMKAAoBQgoRDxYMAwsBBgEAAAAAAAAAFgwBBQcLAAELAwIDAAAAECcGAAAAAAAAAAAMBAoALkENDAUKBAoFIwQZBQsKAAoEDAIuCwJCDRAAFA4BEAAUJAwDBRsJDAMLAwQiCwQGAQAAAAAAAAAWDAQFBgsACwELBDgAAgQAAAASVAYAAAAAAAAAAAwFCgAuQQ0MBgoFCgYjBBAFCwoCBgAAAAAAAAAAJAwDBRIJDAMLAwRKCgAKBUMNDAkKAgoGCgUXEQsMBwoBCgkQABQLBxYRDQwICgILCAoJEAAUFxENDAQKCRAAFAoEFgoJDwAVCwkQABQKASUEPQVBCwABBwUnCwILBBcMAgsFBgEAAAAAAAAAFgwFBQYLAAELAgYAAAAAAAAAACEEUQVTBwMnAgUAAAALFQ4BOAEgBBAFBQ0BRQ0TAAwDDAIKAAsCQwoLAxEOBQALAAELAUYNAAAAAAAAAAACBgAAABZ3BgAAAAAAAAAADAMKAEEKDAQGAAAAAAAAAAAMCQoDCgQjBCMFDAoACgNCChEQDAwKDAYAAAAAAAAAACQEFgUaCwABBwYnCwkLDBYMCQsDBgEAAAAAAAAAFgwDBQcLCQcAIQQoBSwLAAEHAycGAAAAAAAAAAAMAQoBCgQjBHQFMwoBBgEAAAAAAAAAFgwCCgIKBCMEbwU8CgAKAUIKDAoKAAoCQgoMCwoKEQ8MBwoLEQ8MCAsKERAMBQsLERAMBgoHCggkBF0KBQoGJgRZBV0LAAEHBCcLBwsIIwRqCwULBiUEZgVqCwABBwQnCwIGAQAAAAAAAAAWDAIFNwsBBgEAAAAAAAAAFgwBBS4LAAECBwEAAAECBwACCAEAAAECBwECAAEAEgANc3Rha2Vfc3Vic2lkeasGoRzrCwYAAAAMAQAMAgwWAyIlBEcEBUtKB5UBsAIIxQNABoUEEgqXBBQMqwS7AQ3mBQoP8AUEABIBBgEHAQ4BFQEXAAMEAAEADAACAQQBAAEEAgIABQQCAAAIAAEAAAUCAwAACgQFAAEQBwgAAhENDgEAAhgLBQEAAw8MBQAFCgQKBQsCAQgDAwMNBwgEAQgAAQcIAAELAgEIAwEGCAABAwABBwgEAQgBAwQLAgEIAwMBCAMBBgsCAQkAAgMDAgcLAgEJAAMBCwIBCQADQmFnB0JhbGFuY2UDU1VJDFN0YWtlU3Vic2lkeQlUeENvbnRleHQNYWR2YW5jZV9lcG9jaANiYWcHYmFsYW5jZQZjcmVhdGUbY3VycmVudF9kaXN0cmlidXRpb25fYW1vdW50HGN1cnJlbnRfZXBvY2hfc3Vic2lkeV9hbW91bnQUZGlzdHJpYnV0aW9uX2NvdW50ZXIMZXh0cmFfZmllbGRzB2dlbmVzaXMEbWF0aANtaW4DbmV3BXNwbGl0DXN0YWtlX3N1YnNpZHkbc3Rha2Vfc3Vic2lkeV9kZWNyZWFzZV9yYXRlG3N0YWtlX3N1YnNpZHlfcGVyaW9kX2xlbmd0aANzdWkWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lcgp0eF9jb250ZXh0BXZhbHVlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgQQECcAAAAAAAAAAAAAAAAAAAACBgcLAgEIAwsDCQMUAxMNDAgBAAMAAAYTCgMHAEslBAYFCgsEAQYAAAAAAAAAACcLAAYAAAAAAAAAAAsBCwILAwsEEQMSAAIBAwAACTkKABAAFAoAEAE4ABEGDAMKAA8BCwM4AQwCCgAQAhQGAQAAAAAAAAAWCgAPAhUKABACFAoAEAMUGQYAAAAAAAAAACEENQoAEAAUNQoAEAQUNRgHABoMAQoAEAAUCwE0FwsADwAVBTcLAAELAgICAQAABggKABAAFAsAEAE4ABEGAgACAAAAAQADAAQADQAWAA12YWxpZGF0b3JfY2FwmQWhHOsLBgAAAAsBAAgCCBQDHCUEQQQFRS4Hc9sCCM4DQAqOBA0MmwRDDd4EBA/iBAYAEQEKAQ0BDgADDAAABAIAAQAHAAECBAADAQIAAA8AAQAAEwIBAAAJAwQAAAgABQABBgsEAQgBBwgJAAILDAYBDAQKBgoBBggAAQYFAQYIAQIFBwgEAQgCAQgBAAIIAAgCAQcIBAEIAwEIAAEGCQACCQAFAklECVR4Q29udGV4dANVSUQfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcBVWYWxpZGF0b3JPcGVyYXRpb25DYXAcYXV0aG9yaXplcl92YWxpZGF0b3JfYWRkcmVzcwJpZANuZXcTbmV3X2Zyb21fdW52ZXJpZmllZDNuZXdfdW52ZXJpZmllZF92YWxpZGF0b3Jfb3BlcmF0aW9uX2NhcF9hbmRfdHJhbnNmZXIGb2JqZWN0D3B1YmxpY190cmFuc2ZlchZzdWlfc3lzdGVtX3N0YXRlX2lubmVyCHRyYW5zZmVyCnR4X2NvbnRleHQgdW52ZXJpZmllZF9vcGVyYXRpb25fY2FwX2FkZHJlc3MJdmFsaWRhdG9yDXZhbGlkYXRvcl9jYXANdmFsaWRhdG9yX3NldB52ZXJpZmllZF9vcGVyYXRpb25fY2FwX2FkZHJlc3MAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAICBggDBQUBAgEFBQADAAAGAwsAEAACAQMAAAYDCwAQAQICAwAABw0LAREFCgASAAwCDgI4AAwDCwILADgBCwMCAwMAAAYFCwAQABQSAQIAAQEAAAwAEAASAA12YWxpZGF0b3Jfc2V08U+hHOsLBgAAAAwBADMCM2wDnwGEBgSjB4UBBagI1AkH/BGtFwipKWAGiSqRAQqaK2wMhiyYIw2eTxAPrk8FAJ4BAWYBpgECHQIeAjgCZAJwAowBApABApEBApcBAqQBAqUBAIgBAJoBAJ0BAKIBAKkBABIEAAAOAwAADwMAABADAAEEBwEAAAMADAAEAQQBAAEGAwcABwIGAQIABwYGAQIACAcCAAkJDAIHAQQBCgoEAQQBCwsCAAwUBwIBAAAADRUHAQMADgUHAA4ICAAPDQQAEAwMABARAgAREwQAAF8AAQAAewIDAAB9BAMAAHoFAwAAGwYDAAB8BAMAAHkHAwAAfwgDAAB+CQMAABoKAwAAmQELAwAAMwwDAAAuDQ4AAJQBDQ4AAKEBDw4AAJ8BDw4AAKABDxAAAIoBDREAAGINDgAAUA8SAABTBhIAAFITEgAAKhMOAABUBhIAACkUDgAAQxUWAAA7FxgAADwZGAAARhobAABHHBYAAEAdFgAASh4WAABIHxYAAEkfFgAASxcgAABBISAAAEIPIAAARQ8gAACoASIjAABxJAMAAHQlAwAAIiYDAABzJwMAAIQBKAMAAHIpAwAAISoOAAAZKwMAACUsLQAAJi4vAAAnMDEAACQyMQAAMjMDAAA1NAMAAI8BGg4AABcNKgAAWQ8SAABWNRIAATBvUQEAATpQUQEAAVhPEgEAAWMDbwEAAYMBUW8BAAIoUhIBAAJVfRIBAAJ4YVEBAANfOEIABDGUAQMBAARblQEOAQAEhQGTAZQBAQAEowFbDgEABTRRAwEDBkxuEAEIB19naAECB2BlZgECB29pZQECCRg8AwIHBAkfRFUCBwQJIElXAgcECShEEgIHBAlfODkCBwQJeElKAgcECh9tbgEECiBycwEECjY4PQEEClVqEgEECl1qDgEECm6HAVEBBAp1TQMBBAs3SA4AC4ABSDsADChdEgIBAAw2A0ECAQAMP11VAgEADEReVwIBAAxOYAMCAQAMVYIBEgIBAAxcggGDAQIBAAxtjgFfAgEADHheXwIBAAyCAYIBDgIBAA0ohAESAQMNT48BgwEBAw1VhgESAQMNeIUBAwEDDmlUEAAPFksDAA8ZFgMADyMgDgAPLEsDAA8tlgEDAA8zFgMADz0gDgAPUWwSAA9XIBIAD2UgewAPbJgBmQEAD3KKAQMAD3lTAwAPfksDAA9/VgMAD4cBIA4AD4kBIBAAD40BIDsAD5UBIA4AD6kBIA4AEGF5IwAQmAF5dQAQpwF0dQARK0VGABEvRjoAEV5YFgASdgMOABKBASsDABKWAQMOAE83SzdTOk8+Tz9bQE4/Sz9QP1A3Sz5XOjsOOg4+Dk43TDdOPk0+RVpaQGJAXUBeQEA6SQ5IDkoOVTpROk0/PQ48DjkOUjpHej8ORn9agQFigQFggQFdgQFkO2c7ZjtUOlY6RogBW2JeYl+BAWGBAWU7Y2JaYlxiRFpDWkJaXIEBPjtGmgECCggSBwgNAQgAAwcIAAgSBwgNAAIHCAAHCA0DBwgAAwcIDQIGCAAGCBIEBwgABQsGAQgKBwgNAwcIAAgRBwgNAwcIAAMGCA0JBwgABwsGAQgKBwsGAQgKBwsOAgULDwEFAwMDAwcIDQYHCAADAwMHCw4CBQsPAQUHCA0BBwgAAQYIAAEDAgYIAAUBCAcBBgsLAggHBQEBAgYKCBIGCBICBgsMAQgSBggSAgcIAAUBBwgSAgYKCBIFAQsEAQMCBgsMAQgSBQIGCggSBgoFAQoDAgcKCBIFAwcIAAUBAwcIAAYIFAECBwgABggNAQYIEgMHCAAFAgMHCAAGCBMCAQgUAwcIAAcLDgIFCw8BBQcIDQUHCAAIEgcLDgIFCw8BBQEHCA0CBwsOAgULDwEFBQIHCAADAQcKAwIHCggSBwgNAQYKCBIBBwoIEgQKAwMGCgMGCgMEAwsOAgMDAwsOAgMDAgYIAAsOAgULDwEFAgoFAwQGCggSAwMDAgoDCgMJBgoIEgMDCgMKAwMLDgIDAwMLDgIDAwYHCggSBgoDBgoDBwsGAQgKBwsGAQgKBwgNBgMGCggSBgoDBgoDBgsOAgULDwEFBgoFAgYIAAgHBgMDCwsCCAcFAwYIEggAAggHBQEHCA0BCwsCCQAJAQEIEgEFAwcLCwIJAAkBCQAJAQELDAEJAAIIBwgVAgUIFQIFAwELDgIJAAkBAQgFBAYIEgYIEgEFAgYLCwIJAAkBCQACCBIHCA0BCBUDCAcIEgUBBggNAgcLCwIJAAkBCQABCQECBwgSAwUGCBIGCBIBCBIFAgcLDAEJAAkAAwUDCwQBAwEGCwQBCQABBwsEAQkAAQkAAgYKCQAGCQAEBwgSCwYBCAoFBwgNAQYIEQEGCQEDBwgSCBEHCA0BBwkBAQcIFQ4LDgIFCw8BBQYKBQoDCgMLDgIDAwsOAgMDAwoFAwMDAwoDCgMBCAoBBgsGAQkACAMDBwMDCBIIEgUGCBICBgsOAgkACQEGCQACBwsOAgkACQEGCQACCQAJAQMHCw4CCQAJAQkACQECBwoJAAMCAwMKCgsIAQMDAwsJAQMDAwMDBggSBgoIEgELCAEDAgMJAAELCAEJAAEKCwgBCQABCwkBCQABBwsJAQkAAQYLDAEJAAMDAwMCBggSBggSAgYLDAEJAAMBBgkAAQsEAQkABQUDCwQBAwMKAwQDAwsEAQMLBAEDAgcLDAEJAAMBBwkAAQYIFAEGBQIDCwQBAwYBAQMDCwQBAwsEAQMFBQYIEggHBQYIEgEGCBMBCBMBBggHAgMIEgEGCgkAAwMFCAcBCAMHBgUGBQMDBgUKBQcLDwEFAgULDwEFAQYLDgIJAAkBAQoJAAIGCw8BCQAGCQACBwsPAQkABgkAAQYLDwEJAAEHCwwBCQABCAIGAwMDAwMDAgcIEgcIDQQDAwMGCBIHCw4CAwMLDgIDAwQEAwMDBgoFBgoIEgsPAQUKBQMFAQcLDgIJAAkBAQsPAQkABgMDBAoDCgMDEQMDAwoDAwoDAwQDAwMDAwQDAwMIAwMLBgEICgMHCBIFBAsGAQgKAgcLBgEJAAMBCwYBCQACBwsGAQkACwYBCQACBwgSCwYBCAoICgUDAwMDCgUGCBIFAgYIEgMBCBABCAEDQmFnB0JhbGFuY2UFRW50cnkCSUQGT3B0aW9uFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQ1Qcmlvcml0eVF1ZXVlA1NVSQlTdGFrZWRTdWkFVGFibGUIVGFibGVWZWMJVHhDb250ZXh0H1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAJVmFsaWRhdG9yF1ZhbGlkYXRvckVwb2NoSW5mb0V2ZW50ElZhbGlkYXRvckpvaW5FdmVudBNWYWxpZGF0b3JMZWF2ZUV2ZW50FVZhbGlkYXRvck9wZXJhdGlvbkNhcAxWYWxpZGF0b3JTZXQQVmFsaWRhdG9yV3JhcHBlcgZWZWNNYXAGVmVjU2V0CGFjdGl2YXRlEWFjdGl2ZV92YWxpZGF0b3JzA2FkZBphZGp1c3Rfc3Rha2VfYW5kX2dhc19wcmljZQ1hZHZhbmNlX2Vwb2NoJmFzc2VydF9ub19wZW5kaW5nX29yX2FjdGljZV9kdXBsaWNhdGVzEmF0X3Jpc2tfdmFsaWRhdG9ycwNiYWcHYmFsYW5jZQZib3Jyb3cKYm9ycm93X211dBZjYWxjdWxhdGVfdG90YWxfc3Rha2VzJmNsZWFuX3JlcG9ydF9yZWNvcmRzX2xlYXZpbmdfdmFsaWRhdG9yD2NvbW1pc3Npb25fcmF0ZSRjb21wdXRlX2FkanVzdGVkX3Jld2FyZF9kaXN0cmlidXRpb24aY29tcHV0ZV9yZXdhcmRfYWRqdXN0bWVudHMqY29tcHV0ZV9zbGFzaGVkX3ZhbGlkYXRvcnNfYW5kX3RvdGFsX3N0YWtlJmNvbXB1dGVfdW5hZGp1c3RlZF9yZXdhcmRfZGlzdHJpYnV0aW9uCGNvbnRhaW5zGWNvdW50X2R1cGxpY2F0ZXNfdGFibGV2ZWMUY291bnRfZHVwbGljYXRlc192ZWMJY3JlYXRlX3YxCmRlYWN0aXZhdGUVZGVwb3NpdF9zdGFrZV9yZXdhcmRzGmRlcml2ZV9yZWZlcmVuY2VfZ2FzX3ByaWNlB2Rlc3Ryb3kMZGVzdHJveV9zb21lDGRlc3Ryb3lfemVybxFkaXN0cmlidXRlX3Jld2FyZBplZmZlY3R1YXRlX3N0YWdlZF9tZXRhZGF0YQRlbWl0G2VtaXRfdmFsaWRhdG9yX2Vwb2NoX2V2ZW50cwVlbXB0eQVlcG9jaAVldmVudAxleHRyYV9maWVsZHMHZXh0cmFjdA5maW5kX3ZhbGlkYXRvch1maW5kX3ZhbGlkYXRvcl9mcm9tX3RhYmxlX3ZlYwlnYXNfcHJpY2UHZ2VuZXNpcwNnZXQwZ2V0X2FjdGl2ZV9vcl9wZW5kaW5nX29yX2NhbmRpZGF0ZV92YWxpZGF0b3JfbXV0MGdldF9hY3RpdmVfb3JfcGVuZGluZ19vcl9jYW5kaWRhdGVfdmFsaWRhdG9yX3JlZhhnZXRfYWN0aXZlX3ZhbGlkYXRvcl9yZWYlZ2V0X2NhbmRpZGF0ZV9vcl9hY3RpdmVfdmFsaWRhdG9yX211dAdnZXRfbXV0GWdldF9wZW5kaW5nX3ZhbGlkYXRvcl9yZWYVZ2V0X3ZhbGlkYXRvcl9pbmRpY2VzEWdldF92YWxpZGF0b3JfbXV0GmdldF92YWxpZGF0b3JfbXV0X3dpdGhfY3R4L2dldF92YWxpZGF0b3JfbXV0X3dpdGhfY3R4X2luY2x1ZGluZ19jYW5kaWRhdGVzI2dldF92YWxpZGF0b3JfbXV0X3dpdGhfdmVyaWZpZWRfY2FwEWdldF92YWxpZGF0b3JfcmVmAmlkE2luYWN0aXZlX3ZhbGlkYXRvcnMGaW5zZXJ0CWludG9fa2V5cyJpc19hY3RpdmVfdmFsaWRhdG9yX2J5X3N1aV9hZGRyZXNzDGlzX2R1cGxpY2F0ZRZpc19kdXBsaWNhdGVfdmFsaWRhdG9yImlzX2R1cGxpY2F0ZV93aXRoX2FjdGl2ZV92YWxpZGF0b3IjaXNfZHVwbGljYXRlX3dpdGhfcGVuZGluZ192YWxpZGF0b3IIaXNfZW1wdHkVaXNfaW5hY3RpdmVfdmFsaWRhdG9yDGlzX3ByZWFjdGl2ZQdpc19zb21lFmlzX3ZhbGlkYXRvcl9jYW5kaWRhdGUMaXNfdm9sdW50YXJ5BGpvaW4Ea2V5cwZsZW5ndGgcbG9hZF92YWxpZGF0b3JfbWF5YmVfdXBncmFkZQNuZXcJbmV3X2VudHJ5E25ld19mcm9tX3VudmVyaWZpZWQabmV4dF9lcG9jaF92YWxpZGF0b3JfY291bnQEbm9uZQZvYmplY3QQb3BlcmF0aW9uX2NhcF9pZAZvcHRpb24ZcGVuZGluZ19hY3RpdmVfdmFsaWRhdG9ycxBwZW5kaW5nX3JlbW92YWxzB3Bvb2xfaWQTcG9vbF9zdGFraW5nX3Jld2FyZBhwb29sX3Rva2VuX2V4Y2hhbmdlX3JhdGUhcG9vbF90b2tlbl9leGNoYW5nZV9yYXRlX2F0X2Vwb2NoA3BvcAhwb3BfYmFjawdwb3BfbWF4DnByaW9yaXR5X3F1ZXVlGHByb2Nlc3NfcGVuZGluZ19yZW1vdmFscyRwcm9jZXNzX3BlbmRpbmdfc3Rha2VzX2FuZF93aXRoZHJhd3MacHJvY2Vzc19wZW5kaW5nX3ZhbGlkYXRvcnMbcHJvY2Vzc192YWxpZGF0b3JfZGVwYXJ0dXJlCXB1c2hfYmFjaxBxdW9ydW1fdGhyZXNob2xkGnJlZmVyZW5jZV9nYXNfc3VydmV5X3F1b3RlBnJlbW92ZRFyZXF1ZXN0X2FkZF9zdGFrZRVyZXF1ZXN0X2FkZF92YWxpZGF0b3IfcmVxdWVzdF9hZGRfdmFsaWRhdG9yX2NhbmRpZGF0ZRhyZXF1ZXN0X3JlbW92ZV92YWxpZGF0b3IicmVxdWVzdF9yZW1vdmVfdmFsaWRhdG9yX2NhbmRpZGF0ZRtyZXF1ZXN0X3NldF9jb21taXNzaW9uX3JhdGUWcmVxdWVzdF93aXRoZHJhd19zdGFrZQZzZW5kZXIQc2V0X3ZvdGluZ19wb3dlcgRzaXplBHNvbWURc29ydF9yZW1vdmFsX2xpc3QFc3BsaXQFc3Rha2UMc3Rha2VfYW1vdW50DHN0YWtpbmdfcG9vbA9zdGFraW5nX3Bvb2xfaWQVc3Rha2luZ19wb29sX21hcHBpbmdzG3N0b3JhZ2VfZnVuZF9zdGFraW5nX3Jld2FyZANzdWkLc3VpX2FkZHJlc3MWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lch1zdW1fdm90aW5nX3Bvd2VyX2J5X2FkZHJlc3NlcwV0YWJsZQl0YWJsZV92ZWMadGFsbHlpbmdfcnVsZV9nbG9iYWxfc2NvcmUXdGFsbHlpbmdfcnVsZV9yZXBvcnRlcnMLdG90YWxfc3Rha2USdG90YWxfc3Rha2VfYW1vdW50EnRvdGFsX3ZvdGluZ19wb3dlcgp0eF9jb250ZXh0IHVudmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzJ3VwZGF0ZV9hbmRfcHJvY2Vzc19sb3dfc3Rha2VfZGVwYXJ0dXJlcwl2YWxpZGF0b3IRdmFsaWRhdG9yX2FkZHJlc3MUdmFsaWRhdG9yX2NhbmRpZGF0ZXMNdmFsaWRhdG9yX2NhcA12YWxpZGF0b3Jfc2V0FnZhbGlkYXRvcl9zdGFrZV9hbW91bnQZdmFsaWRhdG9yX3N0YWtpbmdfcG9vbF9pZBx2YWxpZGF0b3JfdG90YWxfc3Rha2VfYW1vdW50EXZhbGlkYXRvcl93cmFwcGVyBXZhbHVlB3ZlY19tYXAHdmVjX3NldAZ2ZWN0b3IedmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzCnZlcmlmeV9jYXAMdm90aW5nX3Bvd2VyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgEBAgECAgEDBBAQJwAAAAAAAAAAAAAAAAAAAwgAAAAAAAAAAAMIAQAAAAAAAAADCAIAAAAAAAAAAwgDAAAAAAAAAAMIBAAAAAAAAAADCAUAAAAAAAAAAwgGAAAAAAAAAAMIBwAAAAAAAAADCAgAAAAAAAAAAwgJAAAAAAAAAAMIZQAAAAAAAAAKAwEACgUBAAACCZQBAxcKCBJnCwwBCBJoCgOKAQsLAggHBU0LCwIIBwgVnAELCwIFCBUcCw4CBQM5CAUBAgo3A5sBBXcDhgEDIwNqA4sBA2sIEJMBCgWSAQMCAgM3A5sBBYkBCAcDAgQ3A5sBBYkBCAdaAQADAAA2Mw4AES0MBQoBOAAMBA4AQToMAwYAAAAAAAAAAAwCCgIKAyMEHwUQDgAKAkI6DAYNBAoGEXkLBhF6OAELAgYBAAAAAAAAABYMAgULCwULAAoBOAJADgAAAAAAAAAACwQKATgDCgE4BDgFCwERQRIADAcNBw8AEYQBCwcCAQMAAENFCgAOAQwDLgsDERQgBBEKAA4BDAQuCwQRFyAMBQUTCQwFCwUEFgUcCwABCwIBBwYnDgERegwGCgAQAQoGOAYgBCYFLAsAAQsCAQcKJw4BEXEEMAU2CwABCwIBBwsnCgAPAg4BEXkLBjgBCwAPAQ4BEXoLAQsCEYABOAcCAgMAAEc1CgEuEVkMBAoAEAEKBDgGBAoFEAsAAQsBAQcMJwoADwELBDgIEYEBDAMOAxFxBBoFIAsAAQsBAQcLJw4DEXkMAgoADwIKAjgJAQ0DCgEuEVgRbAsADwMLAgsDCwERgAE4CgIDAwAATEULAi4RWQwHCgAQAQoHOAYECgUOCwABBwwnCgAPAQsHOAgRgQEMBgoADgYMAy4LAxEUIAQlCgAOBgwELgsEERcgDAUFJwkMBQsFBCoFLgsAAQcGJw4GEXEEMgU2CwABBwsnDgYRewsBJgQ8BUALAAEHCScLAA8ECwY4CwIEAwAAAxAKABAACgERFgsAEAQLAREYFgYBAAAAAAAAACEEDQUPBwYnAgUDAABOJAsBLhFZDAIKABAACwIRGgwEDgQ4DAQNBRELAAEGAAAAAAAAAAAnDQQ4DQwDCgAQBQ4DOA4gBBsFHwsAAQYAAAAAAAAAACcLAA8FCwNEDgIGAwAAAwoLAAsBERkLAgoDLhFZCwMRdQIHAwAANysOARFoDAMKABACCgM4DwQWCgAQAg4BEWg4EBQMBAsACwQRGQsBCwIRdwUqCgAQAwoDOBEEHAUiCwABCwIBBwcnCwAPAwsDOBIRggELAQsCEXcCCAMAADsKCwIRWQwDCwAPAAsDER0LARF2AgkDAABZbAoILhFYBgEAAAAAAAAAFgwPCgAQBhQMEgoAEAAKEgoBLjgTCgIuOBMRMQwWDBUKAAoDFAwJLgsJETAMEQwQCgAQAA4QERwLBA4VDhYRLwwODBQMDQwTCgAQAAsSCxELFQsWCxMLDQsUCw4RMgwMDAsKAA8ADgsODAsBCwIKCBEzCgAPABEuCgAPAAoIESwKDwoAEAAOCw4MCgMOEAwKLgsKETQKAAsPESoKAAoDCggRJwoACwULBgsHCwMLCBEKCgAQABEtCgAPBhUKAA8AEYQBCwARCwIKAAAAXGoKABAAQToMBwoHBgAAAAAAAAAAJARjBQkLBwYBAAAAAAAAABcMBwoAEAAKB0I6DA0KDRF6DAwLDRF7DAkKCQoBJgQoCgAQBw4MOBQEJwoADwcODDgVAQEFYgsJCgImBFcKABAHDgw4FARACgAPBw4MOBYMCAoIFAYBAAAAAAAAABYKCBULCBQMBgVHCgAPBwsMBgEAAAAAAAAAOBcGAQAAAAAAAAAMBgsGCgMkBFYKAA8ACgc4GAwKCgALCgoECQoFESgFYgoADwAKBzgYDAsKAAsLCgQJCgURKAUECwQBCwABCwUBAgsAAABiGAoAEABBOgwCBgAAAAAAAAAADAEKAQoCIwQVBQsKAA8ACgFDOhFuCwEGAQAAAAAAAAAWDAEFBgsAAQIMAQAAYzwLABAADAoKCkE6DANAZAAAAAAAAAAADAEGAAAAAAAAAAAMAgoCCgMjBB8FDwoKCgJCOgwJDQEKCRFvCwkRfDgZRGQLAgYBAAAAAAAAABYMAgUKCwoBCwE4GgwEBgAAAAAAAAAADAcRhQERgwEXDAgGAAAAAAAAAAAMBQoHCggjBDoFMQ0EOBsMBgwFCwcLBhYMBwUsCwUCDQEAAAMECwAQBhQCDgEAAAMGCwAQAAsBESIRewIPAQAAAwYLABAACwERIhF4AhABAAADBgsAEAALAREiEXkCEQEAAAMDCwAQAgISAwAAAwwKABAAQToKABAFQQ4XCwAQBDgcFgITAwAAGAgLABAACwERGgwCDgI4DAIUAAAAAwULABAACwERFQIVAwAAAwYLAAsBERYGAAAAAAAAAAAkAhYAAABrIQoAQToMAwYAAAAAAAAAAAwCBgAAAAAAAAAADAQKAgoDIwQbBQwKAAoCQjoKARFwBBYLBAYBAAAAAAAAABYMBAsCBgEAAAAAAAAAFgwCBQcLAAELAQELBAIXAAAAAwcLABAECwERGAYAAAAAAAAAACQCGAAAAGshCgA4HAwDBgAAAAAAAAAADAIGAAAAAAAAAAAMBAoCCgMjBBsFDAoACgI4HQoBEXAEFgsEBgEAAAAAAAAAFgwECwIGAQAAAAAAAAAWDAIFBwsAAQsBAQsEAhkAAAADEAoAEAEKATgGBAsLAA8BCwE4HhGCAQILAA8ACwERHQIaAAAAYh8KAEE6DAMGAAAAAAAAAAAMAgoCCgMjBBsFCgoACgJCOhF6CgEhBBYLAAELAjgfAgsCBgEAAAAAAAAAFgwCBQULAAE4IAIbAAAAYh8KADgcDAMGAAAAAAAAAAAMAgoCCgMjBBsFCgoACgI4HRF6CgEhBBYLAAELAjgfAgsCBgEAAAAAAAAAFgwCBQULAAE4IAIcAAAAcC4KAUE7DAUGAAAAAAAAAAAMAwcPDAYKAwoFIwQoBQwKAQoDQjsUDAIKAAsCERoMBA4EOAwEGQUfCwABCwEBBwgnDQYLBDghRA4LAwYBAAAAAAAAABYMAwUHCwABCwEBCwYCHQMAAE4WCgALAQwCLgsCERoMBA4EOAwECwUPCwABBwgnDQQ4DQwDCwALA0M6Ah4AAABxLQoAEAAKAREaDAUOBTgMBBANBTgNDAMLAA8ACwNDOgIKABAECgERGwwGDgY4DAQgDQY4DQwECwAPBAsEOCICCwIEIwUnCwABBw0nCwAPAQsBOB4RggECHwMAAAMHCwALARF/FAsCER4CIAMAADsICwERWQwCCwALAgkRHgIhAwAAOwgLARFZDAILAAsCCBEeAiIAAAB2EwoACwERGgwDDgM4DAQIBQwLAAEHCCcNAzgNDAILAAsCQjoCIwMAAHc5CgAQAAoBERoMBw4HOAwECwgMAwUPCgIHACEMAwsDBBkNBzgNDAULABAACwVCOgIKABAECgERGwwIDgg4DAQkCAwEBSgLAgcBIQwECwQEMg0IOA0MBgsAEAQLBjgdAgsADwELATgeEYIBLgIkAQAAdhUKABAACwERGgwDDgM4DAQJBQ0LAAEGAAAAAAAAAAAnDQM4DQwCCwAQAAsCQjoCJQEAAHYVCgAQBAsBERsMAw4DOAwECQUNCwABBgAAAAAAAAAAJw0DOA0MAgsAEAQLAjgdAiYDAAB4JwoBEX4UDAYKAgcAIQQQCwALBgwDLgsDESQMBAUVCwALBgsCESMMBAsEDAcKATgjDAULBxFyDgUhBCAFJAsBAQcOJwsBEX0CJwAAAHwgCgAPBRErCgAQBTgkIAQZBQkKAA8FRQ4MAwoADwALAzgYDAQKAAsECgEICgIRKAUDCwEBCwABCwIBAigAAAB+OgoELhFYBgEAAAAAAAAAFgwFDgERegwGDgEReQwHCgAPAgoHOAkBCgAQBw4GOBQEHAoADwcOBjgVAQEKABAGFA4BEXsXCgAPBhULAgoGESkKBQsGDgEReQsDEgM4JQ0BCwURbAsADwMLBwsBCwQRgAE4CgIpAAAAgAFFCgAOAQwCLgsCOCYEDAoADgE4JwEBCgAuOCgMBw4HQTsMBQYAAAAAAAAAAAwECgQKBSMEQgUaDgcKBEI7DAYKAAoGOCkMCAoIDgEMAy4LAzgqBDkKCA4BOCsLCC44LAQ2CgALBjgnAQEFOAsGAQU9CwgBCwYBCwQGAQAAAAAAAAAWDAQFFQsAAQIqAAAAOhwKABAEOC0gBBkFBgoADwQ4LgwCDQIKARFpCgEOAhF6DgIReRICOC8KAA8ACwJEOgUACwABAisAAACJATkKAC5BDgwGBgEAAAAAAAAADAQKBAoGIwQ2BQsKAAoEDAEuCwFCDhQMAwoEDAUKBQYAAAAAAAAAACQEMQUaCwUGAQAAAAAAAAAXDAUKAAoFDAIuCwJCDhQKAyQEKQUqBTEKAAoFCgUGAQAAAAAAAAAWRw4FFQsEBgEAAAAAAAAAFgwEBQYLAAECLAAAAGIaCgAuQToMAwYAAAAAAAAAAAwCCgIKAyMEFQULCgAKAkM6CgERdAsCBgEAAAAAAAAAFgwCBQYLAAELAQECLQAAAIsBHgYAAAAAAAAAAAwDCgBBOgwCBgAAAAAAAAAADAEKAQoCIwQaBQwKAAoBQjoMBAsDCwQRexYMAwsBBgEAAAAAAAAAFgwBBQcLAAELAwIuAAAAYhcKAC5BOgwCBgAAAAAAAAAADAEKAQoCIwQUBQsKAAoBQzoRagsBBgEAAAAAAAAAFgwBBQYLAAECLwAAAIwBRQYAAAAAAAAAAAwIODAMBAYAAAAAAAAAAAwJODAMBQ0ALjgkIAQ8BQ4NAEUODAoKAgoKQg4UNQoBNRgHAxoMBg0ECgoKBjQ4MQsICwY0FgwICgMKCkIOFDUKATUYBwMaDAcNBQsKCgc0ODELCQsHNBYMCQUICwMBCwIBCwgLBAsJCwUCMAAAAI0BMQcQDAUGAAAAAAAAAAAMBg4BODIgBCwFCQ0BODMMBAwHCgAKBxETBBIFFgsAAQcEJwoAEAAMAwsEODQMAgsDDgIRNRGDASYEKwsGCgAKBxEOFgwGDQULB0Q7BQQLAAELBQsGAjEAAACQAS9ADgAAAAAAAAAADAdADgAAAAAAAAAADAgKAEE6DAULAwoFGgwJBgAAAAAAAAAADAQKBAoFIwQqBRIKAAoEQjoRezUKAjUYCgE1GgwGDQcLBjREDg0ICglEDgsEBgEAAAAAAAAAFgwEBQ0LAAELBwsIAjIAAACRAWwLAQsCFwwXQA4AAAAAAAAAAAwMQA4AAAAAAAAAAAwOCgBBOgwUChQOBjg1FwwVBgAAAAAAAAAADBMKEwoUIwRnBRcKAAoTQjoRezUMFg4DChNCDhQMGA4GDhM4NgQwDgYOEzg3FAwPCxgLDxcMCQU9CgU1CxYYChc1GgwQCxgLEDQWDAkLCQwLDQwLC0QODgQKE0IOFAwZDggOEzg2BFUOCA4TODcUDBELGQsRFwwKBV0KBwoVGgwSCxkLEhYMCgsKDA0NDgsNRA4LEwYBAAAAAAAAABYMEwUSCwABCwwLDgIzAAAAkgFpCgAuQToMBwoHBgAAAAAAAAAAJAQJBRcLAAELBAELAwELBQELAgELAQEGAAAAAAAAAAAnBgAAAAAAAAAADAYKBgoHIwRcBR4KAAoGQzoMCgoBCgZCDhQMCQoDCgk4OAwICwk1CgouEWs1GAcDGgwMDQgLDDQ4OAwNDQ0KBAoCCgZCDhQ4ODg5AQ4NOBMGAAAAAAAAAAAkBFIKCi4RegwLCgoLDQsLCgURdQVUCw04OgsKCwgRbQsGBgEAAAAAAAAAFgwGBRkLAAELBAELAwELBQELAgELAQECNAAAAJcBUgoBQToMCQYAAAAAAAAAAAwICggKCSMERwUKCgEKCEI6DAwKDBF6DA0KBA4NOCYEHAoEDg04OxQ4NAwGBR4HEAwGCwYMCwoFDg04PAQnBgAAAAAAAAAADAcFKQYBAAAAAAAAAAwHCwcMCgoACw0KDBFvCgwRewoMEWsKAgoIQg4UCgMKCEIOFAsMCgARcwsLCwoSATg9CwgGAQAAAAAAAAAWDAgFBQsBAQsDAQsFAQsEAQsCAQI1AQAAiwEjBgAAAAAAAAAADAQGAAAAAAAAAAAMAgoBQTsMAwoCCgMjBB0FDAoACgEKAkI7FBEiDAULBAsFEXwWDAQLAgYBAAAAAAAAABYMAgUHCwABCwEBCwQCNgEAAAMDCwAQAAI3AQAAAwULABABCwE4BgI4AQAAAwULABADCwE4EQIAAQAGAAQABQACAAMAAAAHAD4AjgEAEXZhbGlkYXRvcl93cmFwcGVywwShHOsLBgAAAAwBAAgCCBADGDAESAYFTjQHggHTAQjVAkAGlQMKCp8DBgylA2QNiQQCD4sEAgAOAQoBEAAMAAIEAAEAAgACAwwAAwEEAAAFAAEAAAgCAwAABgEEAAALAgUAAA8GBwACBAgJAQQCBgkMAQQCCQoLAQQCDw0HAAUEBwQGBAIIAwcIAQEIAAEHCAABBwgDAQgDAAEGCAABAwMDCQAHCAEBCAIBBwgCAQcJAAEJAAEGCAIJVHhDb250ZXh0CVZhbGlkYXRvchBWYWxpZGF0b3JXcmFwcGVyCVZlcnNpb25lZAZjcmVhdGUJY3JlYXRlX3YxB2Rlc3Ryb3kFaW5uZXIcbG9hZF92YWxpZGF0b3JfbWF5YmVfdXBncmFkZQ5sb2FkX3ZhbHVlX211dAp0eF9jb250ZXh0EXVwZ3JhZGVfdG9fbGF0ZXN0CXZhbGlkYXRvcg12YWxpZGF0b3Jfc2V0EXZhbGlkYXRvcl93cmFwcGVyB3ZlcnNpb24JdmVyc2lvbmVkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMIAAAAAAAAAAAAAgEHCAIAAwAABQYGAQAAAAAAAAALAAsBOAASAAIBAwAABQYKABEDCwAPADgBAgIDAAAFBg0AEQMLABMAOAICAwAAAAUKCwAuEQQGAQAAAAAAAAAhBAcFCQcAJwIEAAAABQQLABAAEQgCAAAADQAWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lcoU/oRzrCwYAAAAMAQAtAi1gA40BywUE2AYyBYoH2QYH4w38HAjfKmAGvyuNAQrMLGsMty3jEA2aPioPxD4EAG0BQQIXAhgCGQIlAkACQwJrAm8CdQJ2AqoBAqsBAGEAZABnAJ0BAJ4BAKIBAAsEAAAJBAAACgMAAQQHAQAAAgAMAAMBBAEAAQQCDAEAAQYDBwAIBQIACQwMAgcBBAELDQIADBIHAgEAAAANEwcBAwAOBgQADwcIABAIBAARDwQAEg4MABIQAgATEQQAABsAAQAAHAIDAABNBAUAAE8GBQAATAYFAABOBgUAAFEHBQAAXQcFAABQCAUAAFwIBQAASgkFAABLCgUAAFILBQAASAwFAAB3DAUAAEkNBQAAeA0FAABTBgUAAJQBDgUAAJIBDgUAAJMBDgUAAJwBDgUAAJUBDgUAAH4OBQAAlwEOBQAAgAEOBQAAmAEOBQAAgQEOBQAAmgEOBQAAgwEOBQAAmQEPBQAAggEPBQAAmwEOBQAAhAEOBQAAlgEOBQAAfw4FAAAUEBEAABUSBQAAIhMUAABEExQAAG4TFAAAKgUUAAAkExQAAKMBFRQAAKQBFRYAAKUBExcAAC0VGAAALxMUAAAuExQAACcZEQABHlw+AQABN1s5AQACPSMkAAMfIgUBAAM4TxQBAANfUyIBAAOpAVEUAQADrgFOIgEAA68BBSIBAAQoXTQBAAQ0NCIBAAUgPgUBAwc5WgUBAApFXgUBDAsiJhQAC1kmJwAMGj05AgEADCEFIAIBAAwrPVcCAQAMLEFCAgEADDNABQIBAAxHQUcCAQANGkM5AQMNIQU/AQMNM0QFAQMNNkY5AQMNR0UFAQMNXj4/AQMOFFIRAA9gNhQAEBRVEQAQPREeABBwUBQAEHJQFAARPSglABE+SAUAEVEwBQARWjMFABFbMAUAEXlJBQARekkFABF7SQUAEXxJBQARfUwFABGFAUkFABGGAUkFABGHAUkFABGIAUkFABGJAUkFABGKAUkFABGLAUkFABGMAUkFABGNAUkFABGOAUwFABGPAUkFABGQAUkFABGRAUkFABKsATs8ABMUVAUAExZLBQATHR0UABMwMi8AEzEyLwATMi4vABM1ODkAEz0bHAATPx0UABNKNQUAE0wrBQATTSkFABNOKgUAE08qBQATUDEFABNSNwUAE2UdFwATcx0UABOkATgWABOmATgUABOtAS0sAEMfOiE8IUIfTSdGH0UfSCdKJ0wnSydHHzkhNiE4ITchPVZEH0knPiEzFDIUOyE/WTUhBwoIEAsFAQgIAwMIAAgNBwgKAQgBCAMDAwMDAwMHCAoBCAAQBwgBCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCAwMHCAoAAgcIAQcICgMHCAEGCBEDAwcIAQMHCAoEBwgBCwYBCAgFBwgKBQcIAQoLBgEICAsDAQMFBwgKAwcIAQgOBwgKAwcIAQYIEQUDCBIFBwsLAgULDAEFAwcIAQoCBggKBAcIAQoCCgIGCAoLBwgBAwMLBQEICAsFAQgIAwMDAwMHCAoBCwUBCAgIBwgBAwMLBQEICAsFAQgIAwMHCAoBBggBAQMCBggBBQEIBwEGCwkCCAcFAQsMAQUDCgsGAQgICwMBAwcICgIDCBMCCggQBwgKAQgTAQYIEwEIDwIFCwwBBQELCwIJAAkBAQgIAQsFAQkAAQcICgEIBAEIEAEGCAoBBRAFCgIKAgoCCgIKAgoCCgIKAgoCCgIKAgoCAwMHCAoDBwgTCBAHCAoCBwgTBwgKAwcIEwMHCAoBCBIDBwgTBggRAgMHCBMGCBIBAQcIEAMHCBAIEgMDBwgTAwYICgIHCBMGCAoCBwgQAwELBgEJAAQHCBMFCwUBCAgHCAoBBggOAwcIEwgOBwgKAgYIEwUBAQQGBQYFBQcLDAEFAQYIEgEGBQIGCwsCCQAJAQYJAAEJAAELDAEJAAMHCwsCCQAJAQkACQECBwsLAgkACQEGCQABBwkBAgYLDAEJAAYJAAIHCwwBCQAJAAIHCwwBCQAGCQABBgsMAQkAAgkACQECBwgQBwgKAgcIEAoCAgcIEAYIEAIGCBMGCBADBwgQCgIKAioBAwMDAwMBAQsFAQgIAwMDAwMDAwMDBAMDAwsFAQgIAwMLBQEICAsFAQgICwUBCAgLBQEICAMDAwsFAQgIBAsFAQgIBAMDAwMEAwEHCwUBCQACBwsFAQkACwUBCQABBggPAQYLBQEJAAEHCA0CBwsFAQkAAwkHCBMHCwUBCAgHCwUBCAgHCwsCBQsMAQUDAwMDBwgKBgcIDwsFAQgICwUBCAgLBQEICAMDAQgCAQYJAQULBQEICAMLBQEICAsGAQgICwUBCAgBCwYBCAgCBwsGAQkACgsGAQkAAQYLAwEJAAELAwEJAAILBQEJAAcICgIJAAUDQmFnB0JhbGFuY2UEQ29pbgJJRAZPcHRpb24DU1VJDFN0YWtlU3Vic2lkeQlTdGFrZWRTdWkLU3RvcmFnZUZ1bmQTU3VpU3lzdGVtU3RhdGVJbm5lchRTeXN0ZW1FcG9jaEluZm9FdmVudBBTeXN0ZW1QYXJhbWV0ZXJzBVRhYmxlCVR4Q29udGV4dB9VbnZlcmlmaWVkVmFsaWRhdG9yT3BlcmF0aW9uQ2FwCVZhbGlkYXRvchVWYWxpZGF0b3JPcGVyYXRpb25DYXAMVmFsaWRhdG9yU2V0BlZlY01hcAZWZWNTZXQNYWR2YW5jZV9lcG9jaBdhZHZhbmNlX2Vwb2NoX3NhZmVfbW9kZSZhc3NlcnRfbm9fcGVuZGluZ19vcl9hY3RpY2VfZHVwbGljYXRlcwNiYWcHYmFsYW5jZQRjb2luCGNvbnRhaW5zBmNyZWF0ZRhjcmVhdGVfc3lzdGVtX3BhcmFtZXRlcnMaZGVyaXZlX3JlZmVyZW5jZV9nYXNfcHJpY2UMZGVzdHJveV9zb21lDGRlc3Ryb3lfemVybwRlbWl0BWVtcHR5BWVwb2NoEWVwb2NoX2R1cmF0aW9uX21zGGVwb2NoX3N0YXJ0X3RpbWVzdGFtcF9tcwVldmVudAxleHRyYV9maWVsZHMUZXh0cmFjdF9jb2luX2JhbGFuY2UMZnJvbV9iYWxhbmNlB2dlbmVzaXMcZ2VuZXNpc19zeXN0ZW1fc3RhdGVfdmVyc2lvbgNnZXQHZ2V0X211dBBnZXRfcmVwb3J0ZXJzX29mH2dldF9zdG9yYWdlX2Z1bmRfb2JqZWN0X3JlYmF0ZXMeZ2V0X3N0b3JhZ2VfZnVuZF90b3RhbF9iYWxhbmNlGmdldF92YWxpZGF0b3JfbXV0X3dpdGhfY3R4L2dldF92YWxpZGF0b3JfbXV0X3dpdGhfY3R4X2luY2x1ZGluZ19jYW5kaWRhdGVzI2dldF92YWxpZGF0b3JfbXV0X3dpdGhfdmVyaWZpZWRfY2FwBmluc2VydAxpbnRvX2JhbGFuY2UiaXNfYWN0aXZlX3ZhbGlkYXRvcl9ieV9zdWlfYWRkcmVzcwhpc19lbXB0eQdpc19zb21lBGpvaW4Iam9pbl92ZWMcbGVmdG92ZXJfc3RvcmFnZV9mdW5kX2luZmxvdxNtYXhfdmFsaWRhdG9yX2NvdW50G21pbl92YWxpZGF0b3Jfam9pbmluZ19zdGFrZQNuZXczbmV3X3VudmVyaWZpZWRfdmFsaWRhdG9yX29wZXJhdGlvbl9jYXBfYW5kX3RyYW5zZmVyGm5leHRfZXBvY2hfdmFsaWRhdG9yX2NvdW50Bm9iamVjdAZvcHRpb24KcGFyYW1ldGVycwNwYXkQcHJvdG9jb2xfdmVyc2lvbg9wdWJsaWNfdHJhbnNmZXITcmVmZXJlbmNlX2dhc19wcmljZQZyZW1vdmUQcmVwb3J0X3ZhbGlkYXRvchVyZXBvcnRfdmFsaWRhdG9yX2ltcGwRcmVxdWVzdF9hZGRfc3Rha2UacmVxdWVzdF9hZGRfc3Rha2VfbXVsX2NvaW4VcmVxdWVzdF9hZGRfdmFsaWRhdG9yH3JlcXVlc3RfYWRkX3ZhbGlkYXRvcl9jYW5kaWRhdGUYcmVxdWVzdF9yZW1vdmVfdmFsaWRhdG9yInJlcXVlc3RfcmVtb3ZlX3ZhbGlkYXRvcl9jYW5kaWRhdGUbcmVxdWVzdF9zZXRfY29tbWlzc2lvbl9yYXRlFXJlcXVlc3Rfc2V0X2dhc19wcmljZRZyZXF1ZXN0X3dpdGhkcmF3X3N0YWtlFHJvdGF0ZV9vcGVyYXRpb25fY2FwCXNhZmVfbW9kZR1zYWZlX21vZGVfY29tcHV0YXRpb25fcmV3YXJkcyRzYWZlX21vZGVfbm9uX3JlZnVuZGFibGVfc3RvcmFnZV9mZWUZc2FmZV9tb2RlX3N0b3JhZ2VfcmViYXRlcxlzYWZlX21vZGVfc3RvcmFnZV9yZXdhcmRzBnNlbmRlch1zZXRfY2FuZGlkYXRlX2NvbW1pc3Npb25fcmF0ZRdzZXRfY2FuZGlkYXRlX2dhc19wcmljZSdzZXRfY2FuZGlkYXRlX3ZhbGlkYXRvcl9jb21taXNzaW9uX3JhdGUhc2V0X2NhbmRpZGF0ZV92YWxpZGF0b3JfZ2FzX3ByaWNlCXNpbmdsZXRvbgVzcGxpdBZzdGFrZV9hY3RpdmF0aW9uX2Vwb2NoDXN0YWtlX3N1YnNpZHkUc3Rha2Vfc3Vic2lkeV9hbW91bnQZc3Rha2Vfc3Vic2lkeV9zdGFydF9lcG9jaAxzdGFraW5nX3Bvb2wVc3Rha2luZ19wb29sX21hcHBpbmdzDnN0b3JhZ2VfY2hhcmdlDHN0b3JhZ2VfZnVuZBRzdG9yYWdlX2Z1bmRfYmFsYW5jZRlzdG9yYWdlX2Z1bmRfcmVpbnZlc3RtZW50DnN0b3JhZ2VfcmViYXRlA3N1aQpzdWlfc3lzdGVtFnN1aV9zeXN0ZW1fc3RhdGVfaW5uZXIUc3lzdGVtX3N0YXRlX3ZlcnNpb24FdGFibGUNdG90YWxfYmFsYW5jZQ50b3RhbF9nYXNfZmVlcxx0b3RhbF9vYmplY3Rfc3RvcmFnZV9yZWJhdGVzC3RvdGFsX3N0YWtlH3RvdGFsX3N0YWtlX3Jld2FyZHNfZGlzdHJpYnV0ZWQIdHJhbnNmZXIKdHhfY29udGV4dBV1bmRvX3JlcG9ydF92YWxpZGF0b3IadW5kb19yZXBvcnRfdmFsaWRhdG9yX2ltcGwgdXBkYXRlX2NhbmRpZGF0ZV9uZXR3b3JrX2FkZHJlc3MfdXBkYXRlX2NhbmRpZGF0ZV9uZXR3b3JrX3B1YmtleRx1cGRhdGVfY2FuZGlkYXRlX3AycF9hZGRyZXNzIHVwZGF0ZV9jYW5kaWRhdGVfcHJpbWFyeV9hZGRyZXNzIHVwZGF0ZV9jYW5kaWRhdGVfcHJvdG9jb2xfcHVia2V5KnVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX25ldHdvcmtfYWRkcmVzcyl1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9uZXR3b3JrX3B1YmtleSZ1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wMnBfYWRkcmVzcyp1cGRhdGVfY2FuZGlkYXRlX3ZhbGlkYXRvcl9wcmltYXJ5X2FkZHJlc3MqdXBkYXRlX2NhbmRpZGF0ZV92YWxpZGF0b3JfcHJvdG9jb2xfcHVia2V5KXVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3dvcmtlcl9hZGRyZXNzKHVwZGF0ZV9jYW5kaWRhdGVfdmFsaWRhdG9yX3dvcmtlcl9wdWJrZXkfdXBkYXRlX2NhbmRpZGF0ZV93b3JrZXJfYWRkcmVzcx51cGRhdGVfY2FuZGlkYXRlX3dvcmtlcl9wdWJrZXkSdXBkYXRlX2Rlc2NyaXB0aW9uEHVwZGF0ZV9pbWFnZV91cmwLdXBkYXRlX25hbWUhdXBkYXRlX25leHRfZXBvY2hfbmV0d29ya19hZGRyZXNzIHVwZGF0ZV9uZXh0X2Vwb2NoX25ldHdvcmtfcHVia2V5HXVwZGF0ZV9uZXh0X2Vwb2NoX3AycF9hZGRyZXNzIXVwZGF0ZV9uZXh0X2Vwb2NoX3ByaW1hcnlfYWRkcmVzcyF1cGRhdGVfbmV4dF9lcG9jaF9wcm90b2NvbF9wdWJrZXkgdXBkYXRlX25leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MfdXBkYXRlX25leHRfZXBvY2hfd29ya2VyX3B1YmtleRJ1cGRhdGVfcHJvamVjdF91cmwcdXBkYXRlX3ZhbGlkYXRvcl9kZXNjcmlwdGlvbhp1cGRhdGVfdmFsaWRhdG9yX2ltYWdlX3VybBV1cGRhdGVfdmFsaWRhdG9yX25hbWUrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX25ldHdvcmtfYWRkcmVzcyp1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfbmV0d29ya19wdWJrZXkndXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3AycF9hZGRyZXNzK3VwZGF0ZV92YWxpZGF0b3JfbmV4dF9lcG9jaF9wcmltYXJ5X2FkZHJlc3MrdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3Byb3RvY29sX3B1YmtleSp1cGRhdGVfdmFsaWRhdG9yX25leHRfZXBvY2hfd29ya2VyX2FkZHJlc3MpdXBkYXRlX3ZhbGlkYXRvcl9uZXh0X2Vwb2NoX3dvcmtlcl9wdWJrZXkcdXBkYXRlX3ZhbGlkYXRvcl9wcm9qZWN0X3VybAl2YWxpZGF0b3INdmFsaWRhdG9yX2NhcCB2YWxpZGF0b3JfbG93X3N0YWtlX2dyYWNlX3BlcmlvZB12YWxpZGF0b3JfbG93X3N0YWtlX3RocmVzaG9sZBh2YWxpZGF0b3JfcmVwb3J0X3JlY29yZHMNdmFsaWRhdG9yX3NldBZ2YWxpZGF0b3Jfc3Rha2VfYW1vdW50GXZhbGlkYXRvcl9zdGFraW5nX3Bvb2xfaWQfdmFsaWRhdG9yX3N0YWtpbmdfcG9vbF9tYXBwaW5ncxx2YWxpZGF0b3JfdG90YWxfc3Rha2VfYW1vdW50InZhbGlkYXRvcl92ZXJ5X2xvd19zdGFrZV90aHJlc2hvbGQKdmFsaWRhdG9ycwV2YWx1ZQd2ZWNfbWFwB3ZlY19zZXQedmVyaWZpZWRfb3BlcmF0aW9uX2NhcF9hZGRyZXNzCnZlcmlmeV9jYXAMd2l0aGRyYXdfYWxsBHplcm8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICAQECAQICAQMDCAEAAAAAAAAAAwgAAAAAAAAAAAMIAgAAAAAAAAADCAMAAAAAAAAAAwgEAAAAAAAAAAMIBQAAAAAAAAADCAYAAAAAAAAAAwgHAAAAAAAAAAQQECcAAAAAAAAAAAAAAAAAAAUgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAggjA2MDOwM8A6ABA6cBA58BAyYIBAECECIDRANuA6gBCBNnCA9CCABGA6EBCwsCBQsMAQVhCA1UAVgLBQEICFULBQEICFcDVgMkAyYIBAICDCIDRANGA3MDaQNmA2oDaANiA3EDdAM6AwADAAAaGwsACgYRcwwIDggRbgwHBgAAAAAAAAAACwIRKQsICwERUQsECwc4AAsFCTgBOAEGAAAAAAAAAAAGAAAAAAAAAAALAwsGETQSAQIBAwAABQsLAAsBCwILAwsECwULBgsHETQSAAICAwAAJRoKDy4RQQsBCwILAwsECwULBgsHCwgLCQsKCwsLDAsNCw4KDxFUDBALAA8ACxALDxF3AgMDAAAFBQsADwALARF5AgQDAAAFGQoAEAARdAoAEAEQAhQjBAoFEAsAAQsBAQcDJwoADwALABABEAMUCwERdgIFAwAABQULAA8ACwEReAIGAwAALA8KAA8ACwEHARGAAQwDCwAPAA4DCRFxCwMLAhFWAgcDAAAsDwoADwALAQcCEYABDAMLAA8ADgMIEXELAwsCEVgCCAMAAAUHCwAPAAsBCwIuEXoCCQMAAAUICwAPAAsCLhFwCwERVwIKAwAABQgLAA8ACwILATgCCwMRdQILAwAAEQwLAQsCCgQRMQwFCwAPAAsDCwULBBF1AgwDAAAFFA4BEU8KAi4RQCUECAUOCwABCwIBBgAAAAAAAAAAJwsADwALAQsCEXsCDQMAAAUWCgAQAAoCEXIEBgUMCwABCwEBBwQnCgAPAAsBBwARgAELAgsADwQRDwIOAwAABQoKAA8ACwEHABGAAQsCCwAPBBEQAg8AAAA6Lg4AEWsUDAUKBQoBIgQJBQ0LAgEHBicKAg4BDAMuCwM4AyAEGwsCCwELBTgEOAUFLQsCDgE4BgwGCgYOBQwELgsEOAcgBCsLBgsFOAgFLQsGAQIQAAAAOjIKAg4BDAMuCwM4AwQIBQwLAgEHBycKAg4BOAYMBg4AEWsUDAUKBg4FDAQuCwQ4BwQcBSILAgELBgEHBycKBg4FOAkLBi44CgQvCwIOATgLAQEFMQsCAQIRAwAABQgLAA8ACgEuEXALARFVAhIDAAAFBwsADwALAhFwCwERYgITAwAABQcLAA8ACwIRcAsBEWACFAMAAAUHCwAPAAsCEXALARFhAhUDAAAFBwsADwALAhFwCwERagIWAwAAShAKAA8ACwIRbwwDCgMLARFjCwMuDAQLABAACwQRbQIXAwAABQcLAA8ACwIRcAsBEVkCGAMAAEoQCgAPAAsCEW8MAwoDCwERZQsDLgwECwAQAAsEEW0CGQMAAAUHCwAPAAsCEXALARFbAhoDAAAFBwsADwALAhFvCwERZgIbAwAABQcLAA8ACwIRcAsBEVwCHAMAAAUHCwAPAAsCEW8LARFoAh0DAAAFBwsADwALAhFwCwERXgIeAwAAShEKAA8ACwMRbwwECgQLAQsCEWcLBC4MBQsAEAALBRFtAh8DAAAFCAsADwALAxFwCwELAhFdAiADAABKEAoADwALAhFvDAMKAwsBEWkLAy4MBAsAEAALBBFtAiEDAAAFBwsADwALAhFwCwERXwIiAwAAShAKAA8ACwIRbwwDCgMLARFkCwMuDAQLABAACwQRbQIjAwAABQcLAA8ACwIRcAsBEVoCJAMAAE2+AgsJCgAPBRUHCzQMGwoHChslBBAKCAsbJQwLBRIJDAsLCwQVBRsLAAELCgEHCCcKAA8GOAwMJg0DCyY4DQEKAA8HOAwMJQ0ECyU4DQELBQoAEAgUFgwFBgAAAAAAAAAACgAPCBULBgoAEAkUFgwGBgAAAAAAAAAACgAPCRUKABAAEX0MNAoAEAoRUgwqCioLNBYMMg4DOA4MKQ4EOA4MHAoKLhFACgAQARALFCYEXwoADwwRTgwTBWE4AQwTCxMMJw4nOA4MKA0ECyc4DQELMjUMMwocNQwdCyo1Cx0YCzMaDC4NBAouNDgPDC0LLgsHNRgHCxoMLA0tCiw0OA8MKwoAEA0UBgEAAAAAAAAAFgoADw0VCwEKABANFCEElwEFnQELAAELCgEGAAAAAAAAAAAnDgQ4DgwfDi04DgwwCgAPAA0EDS0KAA8ECwgKABABEA4UCgAQARAPFAoAEAEQEBQLChFsCgAQABF9DCMOBDgODB4OLTgODC8LHwseFwwgCzALLxcMMQsCCgAPERUKABAAEW4KAA8SFQstDCENIQsEOA0BDiE4DgwiCgAPCgsDCysLIQoFCwYRUAwkCgAQDRQMFAoAEBEUDBUKABASFAwWCyMMFwspDBgLLDQMGQsFDBoKABAKEVIMDAsoDA0LHAwOCyALMRYMDwsiDBALFAsVCxYLFwsZCxgLGgsMCw0LDgsPCxASAjgQCQoADxMVCgAQCBQGAAAAAAAAAAAhBKgCCgAQBjgOBgAAAAAAAAAAIQwRBaoCCQwRCxEEswILABAHOA4GAAAAAAAAAAAhDBIFtwILAAEJDBILEgS6AgW8AgcKJwskAiUDAAAFMgsHLhFBBwwhBAcFCwsAAQYAAAAAAAAAACcLAQoADw0VCwIKAA8RFQgKAA8TFQoADwYLAzgNAQoADwcLBDgNAQoAEAgUCwUWCgAPCBUKABAJFAsGFgsADwkVAiYDAAAFBAsAEA0UAicDAAAFBAsAEBEUAigDAAAFBAsAEBQUAikDAAAFAgcDAioDAAAFBAsAEAUUAisDAAAFBQsAEAALARF/AiwDAAAFBQsAEAALARF+Ai0DAAAFBAsAEAARfAIuAwAAGBIKABAEDgE4AwQMCwAQBA4BOBEUDAIFEAsAATgSDAILAgIvAwAABQQLABAKEVICMAMAAAUECwAQChFTAjEAAABYLQ0ARVkMBg0GCwA4EwsGOAIMBw4BOBQEJwsBOBUMBA0HCwQ4DwwFDgc4DgYAAAAAAAAAACQEIAsHCgI4FgsCLhFBOBcFJAsCAQsHOBgLBQwDBSsLAgELBwwDCwMCAQMBBQACAAMBBwEOAQoBCwEMAQ0BBAABAQgBAAAEAAUABgEBAQYBCQECACkAbAAZDXZhbGlkYXRvcl9jYXAfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9jYXAVVmFsaWRhdG9yT3BlcmF0aW9uQ2FwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMc3Rha2luZ19wb29sC1N0YWtpbmdQb29sAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMc3Rha2luZ19wb29sFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbAlTdGFrZWRTdWkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwl2YWxpZGF0b3IRVmFsaWRhdG9yTWV0YWRhdGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwl2YWxpZGF0b3IJVmFsaWRhdG9yAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMJdmFsaWRhdG9yE1N0YWtpbmdSZXF1ZXN0RXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwl2YWxpZGF0b3IVVW5zdGFraW5nUmVxdWVzdEV2ZW50AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMdm90aW5nX3Bvd2VyD1ZvdGluZ1Bvd2VySW5mbwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEXZhbGlkYXRvcl93cmFwcGVyEFZhbGlkYXRvcldyYXBwZXIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0DFZhbGlkYXRvclNldAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9zZXQXVmFsaWRhdG9yRXBvY2hJbmZvRXZlbnQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3Jfc2V0ElZhbGlkYXRvckpvaW5FdmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9zZXQTVmFsaWRhdG9yTGVhdmVFdmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0b3JhZ2VfZnVuZAtTdG9yYWdlRnVuZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXN0YWtlX3N1YnNpZHkMU3Rha2VTdWJzaWR5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchBTeXN0ZW1QYXJhbWV0ZXJzAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchNTdWlTeXN0ZW1TdGF0ZUlubmVyAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchRTeXN0ZW1FcG9jaEluZm9FdmVudAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADCnN1aV9zeXN0ZW0OU3VpU3lzdGVtU3RhdGUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwdnZW5lc2lzGEdlbmVzaXNWYWxpZGF0b3JNZXRhZGF0YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADB2dlbmVzaXMWR2VuZXNpc0NoYWluUGFyYW1ldGVycwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADB2dlbmVzaXMZVG9rZW5EaXN0cmlidXRpb25TY2hlZHVsZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADB2dlbmVzaXMPVG9rZW5BbGxvY2F0aW9uAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgEAAAAAAAAAAyB44/TodZknpRQWc2/vnAXleCs0lfmbTiUepkK6Yl3dKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwpzdWlfc3lzdGVtDlN1aVN5c3RlbVN0YXRlAAABAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABQEAAAAAAAAAAgEAAAAAAAAAIHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBWNsb2NrBUNsb2NrAAABAAAAAAAAACgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAAAAAgEAAAAAAAAAIHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAQEBAAAAAAAAACgGF8WrkpMHdKDvZPt0hny7/+y3L0xGJ6z8vhor8oo7ugAAQ0/XlGoAAOvI7j9AUZx546TYoA9IGVRS3/z0v2vwAwPhFy1coFD2IHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9jYXAfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAABAQAAAAAAAABACW/+CUtATqdE44JtVHM/G0pIvlMDB/xvW+ue2JSklajPRByVW5lk1lCsBsDxWO5kI/HreBP/9pSwsGjcHsT7NQDPRByVW5lk1lCsBsDxWO5kI/HreBP/9pSwsGjcHsT7NSB44/TodZknpRQWc2/vnAXleCs0lfmbTiUepkK6Yl3dKAAAAAAAAAAAAAIAAQAAAAAAAABQDCBknF9MmNVQCT2TW7kB7Ykxl6SGc3zfhMwOl17gjcjQU9W09ZMZSdLR1HGrSL3OW01BKwU/SJcOHmXgMeiEUgAAAAAAAAAAAACC3+QNRwAAMwjqYXu3Xk4DWZhivz9C4dl2NzAhvjokjJ9rjK1x3Y0geOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKBHGluPYZM7YZ0oSLRKBkXAVEU8hxN/b6OO+qyWtyzTQAABDT9eUagAA/vpauIZ6j+pOlryhGT7TctWnvYzwCo3zIwK+eWB+kDwgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKBpiRlxgUjt2YQebdwdxZlg+cj2T4aYKb5y1M+4WagLIAABDT9eUagAA68juP0BRnHnjpNigD0gZVFLf/PS/a/ADA+EXLVygUPYgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKCDlVVYrjhF4GDR9pV7MJ98e7cecD0begVWoD7TjcVscAABDT9eUagAA68juP0BRnHnjpNigD0gZVFLf/PS/a/ADA+EXLVygUPYgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKCEvCZeJA+FcmArP8IrqCDvFMjeM0iX/d2TykMEnm/TxAABDT9eUagAAzk3v/p6K3cnB+NGEXc47uBM0SENZ6gmljzipfNGR8OsgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKC3xpx+qvVbb1ZOMLnqa+nnbotz+WShAQ3jVoUrNzTIBAABDT9eUagAA/vpauIZ6j+pOlryhGT7TctWnvYzwCo3zIwK+eWB+kDwgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKC7Zg4MjpIWYDGnzwQC8f9HRyVJbOyOKgl/kDlMZN+5uAABDT9eUagAAQs9dwsk3OrqqhDwHNC8i3aM8RbXMS1deIwJnndd9X3EgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKEBGBIaRF3bIPYokdYifZM8uxkJ0TRi5ObpDRv5HiUuSAABDT9eUagAAzk3v/p6K3cnB+NGEXc47uBM0SENZ6gmljzipfNGR8OsgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKErbNUMce/17rcgujTPLnFunjIsQM0c98Jq5fYaOItTnAABDT9eUagAA/vpauIZ6j+pOlryhGT7TctWnvYzwCo3zIwK+eWB+kDwgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKEy2fh22I50BIs0W6gDUE8z3iUrygMk9CA92B1VWtBQlAABDT9eUagAAQs9dwsk3OrqqhDwHNC8i3aM8RbXMS1deIwJnndd9X3EgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKFG299AT5lNsOR9xTD4+IVUuXqZQAFLePjnabCZSKPQIAABDT9eUagAAQs9dwsk3OrqqhDwHNC8i3aM8RbXMS1deIwJnndd9X3EgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKFR6bs83sCCWX6WzwyNXGHxt/GmIAm6LQgQ9qVWtIaORAABDT9eUagAAQs9dwsk3OrqqhDwHNC8i3aM8RbXMS1deIwJnndd9X3EgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAACAAEAAAAAAAAAUFUwJM4SdVTEkHEyYB8ugN/XxU7RS//N8GOGei/0rQNe1YcrnUnTMYWxbnO9DjtyhBDPO9n6zoVDX+GIFxp0JYkAAAAAAAAAAAAAgt/kDUcAAIV2TMLvM6oyu5di063FxzOsrG/BLDGvr4AtelcBU6iMIHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdAJJRAAEAAEAAAAAAAAAYGpegaTvIXMdktVnv75eWqxNJz1OfZ+FWdMty+EtT7rnPwI029eZx+xGbZM/NgMrQKRPR1+zOKoORimY5OcSwxnPRByVW5lk1lCsBsDxWO5kI/HreBP/9pSwsGjcHsT7NQGdSHWE0+cVG78t0zXfrHbeykRoC0ZF3dM7Ljbz6t2CPCB44/TodZknpRQWc2/vnAXleCs0lfmbTiUepkK6Yl3dKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMWc3VpX3N5c3RlbV9zdGF0ZV9pbm5lchNTdWlTeXN0ZW1TdGF0ZUlubmVyAAABAAAAAAAAAJ8aavKit8pgv3YXSt/T6cSVf46Td1lgMYL5tGx/bF8ZxtIBAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAAACH6TNxwBBM9EHJVbmWTWUKwGwPFY7mQj8et4E//2lLCwaNwexPs1YI3P9tFVBAplb0gZsTERtSxXRqhrpy85X7r+LsOEfR6BQOYkp1H99rXyBQvHIFz50wAEyQsMdAr/0ybOZzzCsjotJNU+Kv6yht/GaP1AYAidbSsXt5ndNvkNMy5Up6M41CBmnkTFl3N75K/2bnUrYcT8GVyFv1znTs+T3SSqlHJtPSA+xgcJSknwSa5zfZbWRU0V7gLjuC75jw4QJSg/gf6S1zCgFojv9P9Qw7ncVg+zBDUkAd8H/9ngLJfOCc3f//gzodN+15WOwnN1WoNSqbDsv1ULdmFsaWRhdG9yLTEAAAAdL2lwNC8xMjcuMC4wLjEvdGNwLzM4NDc3L2h0dHAYL2lwNC8xMjcuMC4wLjEvdWRwLzQzMzk5GC9pcDQvMTI3LjAuMC4xL3VkcC8zNTc3NxgvaXA0LzEyNy4wLjAuMS91ZHAvMzUwNzcAAAAAAAAAAKqXU15s13nyZ2Y/5JR3FX3ANNgPbfym37QB+HdGn3J8AAAAAAAAAADECQAAAAAAAAlv/glLQE6nROOCbVRzPxtKSL5TAwf8b1vrntiUpJWoAQAAAAAAAAA/AjTb15nH7EZtkz82AytApE9HX7M4qg5GKZjk5xLDGQEAAAAAAAAAAAAAAILf5A1HAAAAAAAAAAAAAACC3+QNRwCBSSC2ORwhTsi6jFMJxI32dZVaM/cXyVZ+0pvp0xSghgEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlX0M2ZSTyKwkzKSd7pRqD8ZBH0MJl90JXXQJ9GjdYk8AAAAAAAAAAAAAAAAAAAAAAACC3+QNRwABAAAAAAAAAAAAAAAAAAAAOmcn9Iium10OjMH93G91wBtvZ5xHsfR/ZggkRxFEDKEAAAAAAAAAACBErmBD/hkxpZU25gx/AWOkxLbwC9EgS4XEeBavwj37YJnyXvYfgDK5FGNkYJgsXMbxNO8d2udmV/LL/sHr/I0Jc3QIDfb88Ny4vEsNjgr12A67/ytMWZ9U9C1jEt/DFCdgeMHMNH67vsUZi+JYUT84a5MNAsJ0moA+IzCVXr0aECDev1zqIMaRlZPtMMc3OwLsxJW3ovXW1JGSYUUHp2KgziDbVC7oNHVaoTnmGhjVn3Y5+OqpcbeorQk6AVeQMKGOazCpTT1WDICo62evBnW9j3OR1xF0QoaGfGIPYSO8XGafBYi2yAncFmmnECkfVYgHV08LdmFsaWRhdG9yLTAAAAAdL2lwNC8xMjcuMC4wLjEvdGNwLzQxNDE5L2h0dHAYL2lwNC8xMjcuMC4wLjEvdWRwLzQwMjE3GC9pcDQvMTI3LjAuMC4xL3VkcC80MTIwMxgvaXA0LzEyNy4wLjAuMS91ZHAvNDE3NjMAAAAAAAAAAN0YnGWk+SwbYVW1NFopPUKPp1j7dMXkrG8GVo3ev7STAAAAAAAAAADECQAAAAAAAPssOsxvxAfRRgFrHEQRxNjBcK/4yS/gbIFI2K+elC2XAQAAAAAAAABhuWuKHJ2yCmezW/qM5AeUeRSRq1tCdZklXxe8ZRokGQEAAAAAAAAAAAAAAILf5A1HAAAAAAAAAAAAAACC3+QNRwDmnOSG7sJwFcb9OZyoiL97YyHpCXU1aOqGK/odD2bWzQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeSTq3oK8QRpWum+23fH0lpJ8N3HV5qJrPxH+o9fA+/8AAAAAAAAAAAAAAAAAAAAAAACC3+QNRwABAAAAAAAAAAAAAAAAAAAAhZuGPM5IzEdzdsWGiXJtDk77pJmW2QQsp34WxD5SbywAAAAAAAAAAIV2TMLvM6oyu5di063FxzOsrG/BLDGvr4AtelcBU6iMYK3e75TYmMiOQNve/5HF8QX5zyx0f7byvDfsA9bJHtsuGleM9US+iwkx4l8kPVmwww2YoWzjuh1s8df1BCaZLrCtsxNLBVvoFA0ttfJfsA2D+OQiK/Af1qyTof9NedpY8iBXEzmz8g0nfMZ8gkYopLO4ndWibS0vw6bICa45p6vcJiAiSbgUO6xl/Hl7t4Cg/c6psNG4D3Ay9ZoZ2+9ySWFpTTCg+h3BWjOe96jXgSN96QoFmGPvFdbsM2n78jRiUp3pJieiPwlmtolha/984V9YxKELdmFsaWRhdG9yLTIAAAAdL2lwNC8xMjcuMC4wLjEvdGNwLzM2MzQzL2h0dHAYL2lwNC8xMjcuMC4wLjEvdWRwLzMzODA5GC9pcDQvMTI3LjAuMC4xL3VkcC80MTk0MxgvaXA0LzEyNy4wLjAuMS91ZHAvMzk5NTMAAAAAAAAAAMQ5ZO/4sBg66BH2daGqKD6XRZjvt16d3j4Dxj5RIKviAAAAAAAAAADECQAAAAAAAKf60u1lTuz8u5+exIgoUFEE1NOcnm4kalsr81jvvLsjAQAAAAAAAADVhyudSdMxhbFuc70OO3KEEM872frOhUNf4YgXGnQliQEAAAAAAAAAAAAAAILf5A1HAAAAAAAAAAAAAACC3+QNRwAwbIgPd+lhtkgfSLNV3FvFvFwVuMQirOrMQofSBCy6ygEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIeF3HOtiWFotDDeVzIdxeXh8PZdjVdIyKS8Khee8pJMAAAAAAAAAAAAAAAAAAAAAAACC3+QNRwABAAAAAAAAAAAAAAAAAAAAloHEjRx//kr2DMgOn/lh1NauEtEW3uAwg8j7Wtu+6RoAAAAAAAAAADMI6mF7t15OA1mYYr8/QuHZdjcwIb46JIyfa4ytcd2NYLP9XvtchyQDpK0T8RmVE2BtIzVKhFJJrqFXVkwj/zwVxsnmUrctdA6MrLk8vMBoaw7AzAwcdgv7QrQ2UZ/FqAVLdlM6l6nyOYfQl++WsfJSa7IHP6EKdxmUF3I0fvJ09CA4WTZLCf7Xij8UJuN7HiEprX9WCSGz40vLC6bkEm874yBtmFeg173xXO3HvbGD9anriMBJVTFYuqg3E6W8kPGSvTCHmG4Gh6AW5elcK5IsAXPI4dE2K2mr+4dbh7xIJj+L5L294x+BIgr/WM749YYPVBQLdmFsaWRhdG9yLTMAAAAdL2lwNC8xMjcuMC4wLjEvdGNwLzM5OTc1L2h0dHAYL2lwNC8xMjcuMC4wLjEvdWRwLzM4NDcxGC9pcDQvMTI3LjAuMC4xL3VkcC80NDk2NxgvaXA0LzEyNy4wLjAuMS91ZHAvMzQzOTUAAAAAAAAAAA1TL2vPLU3uzx298w6rXLdwwSW62wlA8fUjZnfoRFlwAAAAAAAAAADECQAAAAAAANnmCLbzawGGKY7uOg3TpkzDDjgf/8vgNiEdN/CGS2vrAQAAAAAAAADQU9W09ZMZSdLR1HGrSL3OW01BKwU/SJcOHmXgMeiEUgEAAAAAAAAAAAAAAILf5A1HAAAAAAAAAAAAAACC3+QNRwDHRGC9SZRsvXrx1dgYMV5yksEYkCM18r8BU2K9RLnm7AEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAzwILgj9go36EPdoc1we6K9Kb8YQRAn7ZJvA76/fYi9YAAAAAAAAAAAAAAAAAAAAAAACC3+QNRwABAAAAAAAAAAAAAAAAAAAAr5/1OeFJIr9R30vfFph31tk9DgW/agvM0bp0CCpzQ4IAAAAAAAAAAM0S7p98jj7SnNlN3HUOQvNotpqwkDCgztY3JbQeNb4kAAAAAAAAAAAAnUh1hNPnFRu/LdM136x23spEaAtGRd3TOy428+rdgjwEAAAAAAAAAGM4jxryljEa5hLfEPRGHEm4ye+xzYhmWYO7lKVKNW1dAAAAAAAAAAAnA91owUlXjUVkXAiVfZVL6skhY8iSw++IDnbjbzEgiwAAAAAAAAAAAEXh7PyWkJDZ0GL0QWAiY9UNFA4tpQiwhr4O6XFMZvDSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFwmBQAAAAAAAAAAAAAAAJYAAAAAAAAAAABDT9eUagAAAILf5A1HAACAoadrSjUABwAAAAAAAABNzc9bOCK6etRpSAUlBdODMaADuelHnJaVad6T1iHHHAAAAAAAAAAAAQAAAAAAAAAAAADgC3HrqokAAAAAAAAAAACAxqR+jQMAHgAAAAAAAAAQJ0KuWN+zw6B9uSbsBiLIUg5nDFTL8X3eO0yC9Bpmg651AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFQv5RhwEAAG4p/08TLbg/67J16NDwDk5mxVdIa0nGlF+OwBv0h0drAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEY29pbgxDb2luTWV0YWRhdGEBBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3N1aQNTVUkAAQEAAAAAAAAAK2uZ2jPvcv3kbg2jdeLVda9GrYCx8AtQpzwUVRo/mPYnCQNTdWkDU1VJAAADIHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAQEBAAAAAAAAAChr45o2Zcp2UowQ2OJJ/Pu3ySSjerQO5BSI4p2iDQD/ywAAQ0/XlGoAAP76WriGeo/qTpa8oRk+03LVp72M8AqN8yMCvnlgfpA8IHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCAgcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwxzdGFraW5nX3Bvb2wVUG9vbFRva2VuRXhjaGFuZ2VSYXRlAAABAAAAAAAAADh422Xy3cMY+hHJ7xjIyUrFeINn7vKGpbLjgwXQtF3nZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEwbIgPd+lhtkgfSLNV3FvFvFwVuMQirOrMQofSBCy6yiB44/TodZknpRQWc2/vnAXleCs0lfmbTiUepkK6Yl3dKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMc3Rha2luZ19wb29sFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQAAAQAAAAAAAAA4e3yVyYez942eg1XiEZhpJxAwu0SFbQq7OBuoGXBWDcYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABx0RgvUmUbL168dXYGDFecpLBGJAjNfK/AVNivUS55uwgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKJMvIG28BzxT9r/G7oXnzrjgwYFEZZH+HfYft8w+GWGKAABDT9eUagAAQs9dwsk3OrqqhDwHNC8i3aM8RbXMS1deIwJnndd9X3EgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKJmW1Rq45mtmfvIjxDfy/PRiwO4kDRO1tGMK4aFSfbbZAABDT9eUagAAmQEejQyRGgeeU4GTtj4k2t74m1GzF4IXmERjSQl0vbwgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKJrfDdtUp8YjzIe0Ti05kvZiC2QNt9Tlfe+OhR3HCRVWAABDT9eUagAAmQEejQyRGgeeU4GTtj4k2t74m1GzF4IXmERjSQl0vbwgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAICBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDHN0YWtpbmdfcG9vbBVQb29sVG9rZW5FeGNoYW5nZVJhdGUAAAEAAAAAAAAAOKNFuyo96ZIROVDG2mSznPWwCK2FGswBDg70IdIswtpcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAeac5IbuwnAVxv05nKiIv3tjIekJdTVo6oYr+h0PZtbNIHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAQEBAAAAAAAAACikxkr1MEWocjPzwzdlG2gpyhOjwljP/SxMIcVaEVbHvQAAQ0/XlGoAAM5N7/6eit3JwfjRhF3OO7gTNEhDWeoJpY84qXzRkfDrIHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDXZhbGlkYXRvcl9jYXAfVW52ZXJpZmllZFZhbGlkYXRvck9wZXJhdGlvbkNhcAABAQAAAAAAAABAp/rS7WVO7Py7n57EiChQUQTU05yebiRqWyvzWO+8uyOFdkzC7zOqMruXYtOtxcczrKxvwSwxr6+ALXpXAVOojACFdkzC7zOqMruXYtOtxcczrKxvwSwxr6+ALXpXAVOojCB44/TodZknpRQWc2/vnAXleCs0lfmbTiUepkK6Yl3dKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAg1keW5hbWljX2ZpZWxkBUZpZWxkAgIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMc3Rha2luZ19wb29sFVBvb2xUb2tlbkV4Y2hhbmdlUmF0ZQAAAQAAAAAAAAA4sDTHrPfXIyKMGSa+31mMWMKc427DamG9y4vIg35ylE4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgUkgtjkcIU7IuoxTCcSN9nWVWjP3F8lWftKb6dMUoIYgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAABAQEAAAAAAAAAKLaNwRd5c1oIP35RzQjdQnifCDZW8ThXwfPNb1mgOHkyAABDT9eUagAA68juP0BRnHnjpNigD0gZVFLf/PS/a/ADA+EXLVygUPYgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGb2JqZWN0AklEAAQAAQAAAAAAAABgt4JXXJY+im4a53btS7bOolJlvweAUJfifRMyUgPloUFhuWuKHJ2yCmezW/qM5AeUeRSRq1tCdZklXxe8ZRokGSBErmBD/hkxpZU25gx/AWOkxLbwC9EgS4XEeBavwj37AZ1IdYTT5xUbvy3TNd+sdt7KRGgLRkXd0zsuNvPq3YI8IHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAQEBAAAAAAAAACi7WLun6pKkDUT8KkmqJ5/sXmykjwVW8P6iqlClCEH4fAAAQ0/XlGoAAM5N7/6eit3JwfjRhF3OO7gTNEhDWeoJpY84qXzRkfDrIHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAQEBAAAAAAAAACi9AeeI1TOLa2hFlbsO944HRc49dgQs6f2hNS4VA8b3RQAAQ0/XlGoAAOvI7j9AUZx546TYoA9IGVRS3/z0v2vwAwPhFy1coFD2IHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAQEBAAAAAAAAACi+lePJYAMWl6kIjlbO7EnDHd3dBgS0IgX8wl92C6HRQwAAQ0/XlGoAAM5N7/6eit3JwfjRhF3OO7gTNEhDWeoJpY84qXzRkfDrIHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACDWR5bmFtaWNfZmllbGQFRmllbGQCBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACBm9iamVjdAJJRAAEAAEAAAAAAAAAYMHFVR7A6jl/VVnz9u0liLvmU81lqCzlL4wM2bKKGQGX0FPVtPWTGUnS0dRxq0i9zltNQSsFP0iXDh5l4DHohFIzCOphe7deTgNZmGK/P0Lh2XY3MCG+OiSMn2uMrXHdjQGdSHWE0+cVG78t0zXfrHbeykRoC0ZF3dM7Ljbz6t2CPCB44/TodZknpRQWc2/vnAXleCs0lfmbTiUepkK6Yl3dKAAAAAAAAAAAAAEBAQAAAAAAAAAow30G/l7op4L/UtLwEw3td+sFP1schO25wzb8y7wR5cUAAENP15RqAACZAR6NDJEaB55TgZO2PiTa3vibUbMXgheYRGNJCXS9vCB44/TodZknpRQWc2/vnAXleCs0lfmbTiUepkK6Yl3dKAAAAAAAAAAAAAEBAQAAAAAAAAAo16lyyPXUzprS+1JflBILdWr2ZeIRT2/fIi4SFDvLA1oAAENP15RqAAD++lq4hnqP6k6WvKEZPtNy1ae9jPAKjfMjAr55YH6QPCB44/TodZknpRQWc2/vnAXleCs0lfmbTiUepkK6Yl3dKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3JfY2FwH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAAAQEAAAAAAAAAQNnmCLbzawGGKY7uOg3TpkzDDjgf/8vgNiEdN/CGS2vrMwjqYXu3Xk4DWZhivz9C4dl2NzAhvjokjJ9rjK1x3Y0AMwjqYXu3Xk4DWZhivz9C4dl2NzAhvjokjJ9rjK1x3Y0geOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAINZHluYW1pY19maWVsZAVGaWVsZAIHAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIGb2JqZWN0AklEAAQAAQAAAAAAAABg3hR50VtESehA0BwPjDW1mN9AEdbKqM7hBeWLLRotqlvVhyudSdMxhbFuc70OO3KEEM872frOhUNf4YgXGnQliYV2TMLvM6oyu5di063FxzOsrG/BLDGvr4AtelcBU6iMAZ1IdYTT5xUbvy3TNd+sdt7KRGgLRkXd0zsuNvPq3YI8IHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAQEBAAAAAAAAACjqHtqSPlqLap5rENols6Obf5hmrkTsZjBa2KRH6XcRSwAAQ0/XlGoAAJkBHo0MkRoHnlOBk7Y+JNre+JtRsxeCF5hEY0kJdL28IHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAAAAgABAAAAAAAAAFD07lM3cwN6oPWNPvvq2Aa3CS+8OnuE2pexTgS4QMmz0WG5a4ocnbIKZ7Nb+ozkB5R5FJGrW0J1mSVfF7xlGiQZAAAAAAAAAAAAAILf5A1HAAAgRK5gQ/4ZMaWVNuYMfwFjpMS28AvRIEuFxHgWr8I9+yB44/TodZknpRQWc2/vnAXleCs0lfmbTiUepkK6Yl3dKAAAAAAAAAAAAAEBAQAAAAAAAAAo92RqpWeT//rZjfQWaTX+lsnR4zuZ1WjdciI6giIBAo0AAENP15RqAACZAR6NDJEaB55TgZO2PiTa3vibUbMXgheYRGNJCXS9vCB44/TodZknpRQWc2/vnAXleCs0lfmbTiUepkK6Yl3dKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAw12YWxpZGF0b3JfY2FwH1VudmVyaWZpZWRWYWxpZGF0b3JPcGVyYXRpb25DYXAAAQEAAAAAAAAAQPssOsxvxAfRRgFrHEQRxNjBcK/4yS/gbIFI2K+elC2XIESuYEP+GTGllTbmDH8BY6TEtvAL0SBLhcR4Fq/CPfsAIESuYEP+GTGllTbmDH8BY6TEtvAL0SBLhcR4Fq/CPfsgeOP06HWZJ6UUFnNv75wF5XgrNJX5m04lHqZCumJd3SgAAAAAAAAAAAACAAEAAAAAAAAAUP0EQi1VtnzJTDTxP07KFmJlUU5Ls786tvTr3+kLzpoXPwI029eZx+xGbZM/NgMrQKRPR1+zOKoORimY5OcSwxkAAAAAAAAAAAAAgt/kDUcAAM9EHJVbmWTWUKwGwPFY7mQj8et4E//2lLCwaNwexPs1IHjj9Oh1mSelFBZzb++cBeV4KzSV+ZtOJR6mQrpiXd0oAAAAAAAAAAA= diff --git a/sui/ts/tests/sui_config/sui.keystore b/sui/ts/tests/sui_config/sui.keystore new file mode 100644 index 0000000..a3f456b --- /dev/null +++ b/sui/ts/tests/sui_config/sui.keystore @@ -0,0 +1,7 @@ +[ + "AEDorSqM3nYmNeja26rmaddyyZ4dMpSoEYWxT71+AWbD", + "AJaQFexEWr4WS7UxY2yEBNZLTI0FCkI8QNWm23bUNA10", + "AGqJryHqVVP9ao23QCKlUno1WA9ykGJQpKjb5/ruejhh", + "APJ/2Q0dnylqY4+QW8ec/oNVs3y0QyVljHJa5Dw15Lvt", + "ACMS4emBUzUD0vcYoiSM2Z8i2qs4MMrKeFRZY3L/pXYK" +] \ No newline at end of file diff --git a/sui/ts/tests/sui_config/validator-config-0.yaml b/sui/ts/tests/sui_config/validator-config-0.yaml new file mode 100644 index 0000000..a11faf7 --- /dev/null +++ b/sui/ts/tests/sui_config/validator-config-0.yaml @@ -0,0 +1,73 @@ +--- +protocol-key-pair: + value: VTDx4HjVmRBqdqBWg2zN+zcFE20io3CrBchGy/iV1lo= +worker-key-pair: + value: AADxeIjGebS2URkFA5t9jQ8638QMC2nUj6v6xIVj2lOz +account-key-pair: + value: ANK1fjgOf2GTXSE0m9sZjlrGnr+WzWyCkItHGtlENbrI +network-key-pair: + value: ALmQEkz1SUpqhCftqoXRGjkF7qglhH3ig4VXnU3+/+lT +db-path: ts/tests/sui_config/authorities_db/99f25ef61f80 +network-address: /ip4/127.0.0.1/tcp/41419/http +json-rpc-address: "127.0.0.1:42489" +metrics-address: "127.0.0.1:35781" +admin-interface-port: 41707 +consensus-config: + address: /ip4/127.0.0.1/tcp/38819/http + db-path: ts/tests/sui_config/consensus_db/99f25ef61f80 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/37013/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/42677/http + network_admin_server: + primary_network_admin_server_port: 43965 + worker_network_admin_server_base_port: 33157 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ +enable-event-processing: false +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:40217" + external-address: /ip4/127.0.0.1/udp/40217 +genesis: + genesis-file-location: ts/tests/sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 1 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 10 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 diff --git a/sui/ts/tests/sui_config/validator-config-1.yaml b/sui/ts/tests/sui_config/validator-config-1.yaml new file mode 100644 index 0000000..bab9661 --- /dev/null +++ b/sui/ts/tests/sui_config/validator-config-1.yaml @@ -0,0 +1,73 @@ +--- +protocol-key-pair: + value: avYcyVgYMXTyaUYh9IRwLK0gSzl7YF6ZQDAbrS1Bhvo= +worker-key-pair: + value: ANwIykK/Bc5CjfRl3UjbX1J+ZM8IrAL/eNkSN5mVtCfb +account-key-pair: + value: AEVJNm8X9UqeqG4Ba93vCOZAubzT6gD/hIkfEHN0+vDj +network-key-pair: + value: AAR+w04MHiPvGT9s8RN1H4xtmeSW7nQtOjLh5TkvzQpq +db-path: ts/tests/sui_config/authorities_db/8dcff6d15504 +network-address: /ip4/127.0.0.1/tcp/38477/http +json-rpc-address: "127.0.0.1:45869" +metrics-address: "127.0.0.1:45197" +admin-interface-port: 34033 +consensus-config: + address: /ip4/127.0.0.1/tcp/46699/http + db-path: ts/tests/sui_config/consensus_db/8dcff6d15504 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/33681/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/44867/http + network_admin_server: + primary_network_admin_server_port: 35151 + worker_network_admin_server_base_port: 46805 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ +enable-event-processing: false +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:43399" + external-address: /ip4/127.0.0.1/udp/43399 +genesis: + genesis-file-location: ts/tests/sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 1 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 10 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 diff --git a/sui/ts/tests/sui_config/validator-config-2.yaml b/sui/ts/tests/sui_config/validator-config-2.yaml new file mode 100644 index 0000000..ecab8cf --- /dev/null +++ b/sui/ts/tests/sui_config/validator-config-2.yaml @@ -0,0 +1,73 @@ +--- +protocol-key-pair: + value: OXnx3yM1C/ppgnDMx/o1d49fJs7E05kq11mXNae/O+I= +worker-key-pair: + value: APFaE/LsORvf5ajtHEZIC5B9tSxnoB4SD7otcaVioocx +account-key-pair: + value: AOwFNNwaP6UVhZ4B4gLIx2+0PI9fVwBenafL5VuoDHEg +network-key-pair: + value: ANnediYYt8nwYMt1Jix9qm2bJUxSQLeTgkiYy4Qd07hq +db-path: ts/tests/sui_config/authorities_db/addeef94d898 +network-address: /ip4/127.0.0.1/tcp/36343/http +json-rpc-address: "127.0.0.1:46019" +metrics-address: "127.0.0.1:41631" +admin-interface-port: 46301 +consensus-config: + address: /ip4/127.0.0.1/tcp/40065/http + db-path: ts/tests/sui_config/consensus_db/addeef94d898 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/46517/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/43275/http + network_admin_server: + primary_network_admin_server_port: 41311 + worker_network_admin_server_base_port: 38867 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ +enable-event-processing: false +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:33809" + external-address: /ip4/127.0.0.1/udp/33809 +genesis: + genesis-file-location: ts/tests/sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 1 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 10 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 diff --git a/sui/ts/tests/sui_config/validator-config-3.yaml b/sui/ts/tests/sui_config/validator-config-3.yaml new file mode 100644 index 0000000..9041e86 --- /dev/null +++ b/sui/ts/tests/sui_config/validator-config-3.yaml @@ -0,0 +1,73 @@ +--- +protocol-key-pair: + value: CyNkjqNVr3HrHTH7f/NLs7u5lUHJzuPAw0PqMTD2y2s= +worker-key-pair: + value: ALe5f9owpcZeOBolxs60Fnuv2zRISbB14J+87XP4hiA1 +account-key-pair: + value: APg5GMTm6C6BVL6c0VDXiUmUbXSfHCW/tK4N+6Zcl0al +network-key-pair: + value: AE50PIMLxjfzhjvLX+8/vPo5lWh49okxNQZm1o2N+lSq +db-path: ts/tests/sui_config/authorities_db/b3fd5efb5c87 +network-address: /ip4/127.0.0.1/tcp/39975/http +json-rpc-address: "127.0.0.1:41115" +metrics-address: "127.0.0.1:35859" +admin-interface-port: 35517 +consensus-config: + address: /ip4/127.0.0.1/tcp/45685/http + db-path: ts/tests/sui_config/consensus_db/b3fd5efb5c87 + internal-worker-address: ~ + max-pending-transactions: ~ + narwhal-config: + header_num_of_batches_threshold: 32 + max_header_num_of_batches: 1000 + max_header_delay: 2000ms + min_header_delay: 500ms + gc_depth: 50 + sync_retry_delay: 5000ms + sync_retry_nodes: 3 + batch_size: 500000 + max_batch_delay: 100ms + block_synchronizer: + range_synchronize_timeout: 30000ms + certificates_synchronize_timeout: 30000ms + payload_synchronize_timeout: 30000ms + payload_availability_timeout: 30000ms + handler_certificate_deliver_timeout: 30000ms + consensus_api_grpc: + socket_addr: /ip4/127.0.0.1/tcp/34665/http + get_collections_timeout: 5000ms + remove_collections_timeout: 5000ms + max_concurrent_requests: 500000 + prometheus_metrics: + socket_addr: /ip4/127.0.0.1/tcp/45329/http + network_admin_server: + primary_network_admin_server_port: 33461 + worker_network_admin_server_base_port: 35171 + anemo: + send_certificate_rate_limit: ~ + get_payload_availability_rate_limit: ~ + get_certificates_rate_limit: ~ + report_batch_rate_limit: ~ + request_batch_rate_limit: ~ +enable-event-processing: false +grpc-load-shed: ~ +grpc-concurrency-limit: 20000000000 +p2p-config: + listen-address: "127.0.0.1:38471" + external-address: /ip4/127.0.0.1/udp/38471 +genesis: + genesis-file-location: ts/tests/sui_config/genesis.blob +authority-store-pruning-config: + num-latest-epoch-dbs-to-retain: 3 + epoch-db-pruning-period-secs: 3600 + num-epochs-to-retain: 1 + max-checkpoints-in-batch: 200 + max-transactions-in-batch: 1000 + use-range-deletion: true +end-of-epoch-broadcast-channel-capacity: 128 +checkpoint-executor-config: + checkpoint-execution-max-concurrency: 200 + local-execution-timeout-sec: 10 +db-checkpoint-config: + perform-db-checkpoints-at-epoch-end: false +indirect-objects-threshold: 18446744073709551615 diff --git a/sui/tsconfig.json b/sui/tsconfig.json new file mode 100644 index 0000000..b0a2ac3 --- /dev/null +++ b/sui/tsconfig.json @@ -0,0 +1,13 @@ +{ + "compilerOptions": { + "types": ["mocha", "chai"], + "typeRoots": ["./node_modules/@types"], + "lib": ["es2020", "DOM"], + "module": "commonjs", + "target": "es2020", + "strict": true, + "resolveJsonModule": true, + "esModuleInterop": true + }, + "include": ["ts/scripts"] +} diff --git a/sui/yarn.lock b/sui/yarn.lock new file mode 100644 index 0000000..caae994 --- /dev/null +++ b/sui/yarn.lock @@ -0,0 +1,3710 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"@apollo/client@^3.5.8": + version "3.7.14" + resolved "https://registry.yarnpkg.com/@apollo/client/-/client-3.7.14.tgz#40ef90390e6690e94917457cd82bdeb29e8b6af9" + integrity sha512-BRvdkwq5PAXBkjXjboO12uksDm3nrZEqDi4xF97Fk3Mnaa0zDOEfJa7hoKTY9b9KA1EkeWv9BL3i7hSd4SfGBg== + dependencies: + "@graphql-typed-document-node/core" "^3.1.1" + "@wry/context" "^0.7.0" + "@wry/equality" "^0.5.0" + "@wry/trie" "^0.3.0" + graphql-tag "^2.12.6" + hoist-non-react-statics "^3.3.2" + optimism "^0.16.2" + prop-types "^15.7.2" + response-iterator "^0.2.6" + symbol-observable "^4.0.0" + ts-invariant "^0.10.3" + tslib "^2.3.0" + zen-observable-ts "^1.2.5" + +"@babel/runtime@7.20.13": + version "7.20.13" + resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.20.13.tgz#7055ab8a7cff2b8f6058bf6ae45ff84ad2aded4b" + integrity sha512-gt3PKXs0DBoL9xCvOIIZ2NEqAGZqHjAnmVbfQtB620V0uReIQutpel14KcneZuer7UioY8ALKZ7iocavvzTNFA== + dependencies: + regenerator-runtime "^0.13.11" + +"@babel/runtime@^7.12.5": + version "7.21.5" + resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.21.5.tgz#8492dddda9644ae3bda3b45eabe87382caee7200" + integrity sha512-8jI69toZqqcsnqGGqwGS4Qb1VwLOEp4hz+CXPywcvjs60u3B4Pom/U/7rm4W8tMOYEB+E9wgD0mW1l3r8qlI9Q== + dependencies: + regenerator-runtime "^0.13.11" + +"@babel/runtime@^7.17.2": + version "7.20.7" + resolved "https://registry.npmjs.org/@babel/runtime/-/runtime-7.20.7.tgz" + integrity sha512-UF0tvkUtxwAgZ5W/KrkHf0Rn0fdnLDU9ScxBrEVNUprE/MzirjK4MJUX1/BVDv00Sv8cljtukVK1aky++X1SjQ== + dependencies: + regenerator-runtime "^0.13.11" + +"@certusone/wormhole-sdk-proto-web@0.0.6": + version "0.0.6" + resolved "https://registry.yarnpkg.com/@certusone/wormhole-sdk-proto-web/-/wormhole-sdk-proto-web-0.0.6.tgz#cd26f724b39e565cde5573e20f0a29e659d146d3" + integrity sha512-LTyjsrWryefx5WmkoBP6FQ2EjLxhMExAGxLkloHUhufVQZdrbGh0htBBUviP+HaDSJBCMPMtulNFwkBJV6muqQ== + dependencies: + "@improbable-eng/grpc-web" "^0.15.0" + protobufjs "^7.0.0" + rxjs "^7.5.6" + +"@certusone/wormhole-sdk-wasm@^0.0.1": + version "0.0.1" + resolved "https://registry.yarnpkg.com/@certusone/wormhole-sdk-wasm/-/wormhole-sdk-wasm-0.0.1.tgz#05f0c05acba3df5bd025eaa9c7a3d55e017a771f" + integrity sha512-LdIwLhOyr4pPs2jqYubqC7d4UkqYBX0EG/ppspQlW3qlVE0LZRMrH6oVzzLMyHtV0Rw7O9sIKzORW/T3mrJv2w== + dependencies: + "@types/long" "^4.0.2" + "@types/node" "^18.0.3" + +"@certusone/wormhole-sdk@^0.9.16": + version "0.9.16" + resolved "https://registry.yarnpkg.com/@certusone/wormhole-sdk/-/wormhole-sdk-0.9.16.tgz#26c84c8ec2f82e975ce5e163a22cb44e01aa707b" + integrity sha512-UFcGvMW6yku0Qz4hyFw0H4IKKlUJ2VHrHo0PnSUOfbBf7RfXHKPE9VxsVeCKILbhBzBmECVVP4xF7WlrBBn8/Q== + dependencies: + "@certusone/wormhole-sdk-proto-web" "0.0.6" + "@certusone/wormhole-sdk-wasm" "^0.0.1" + "@coral-xyz/borsh" "0.2.6" + "@injectivelabs/networks" "1.10.7" + "@injectivelabs/sdk-ts" "1.10.47" + "@injectivelabs/utils" "1.10.5" + "@mysten/sui.js" "0.32.2" + "@project-serum/anchor" "^0.25.0" + "@solana/spl-token" "^0.3.5" + "@solana/web3.js" "^1.66.2" + "@terra-money/terra.js" "^3.1.3" + "@xpla/xpla.js" "^0.2.1" + algosdk "^1.15.0" + aptos "1.5.0" + axios "^0.24.0" + bech32 "^2.0.0" + binary-parser "^2.2.1" + bs58 "^4.0.1" + elliptic "^6.5.4" + js-base64 "^3.6.1" + near-api-js "^1.0.0" + +"@classic-terra/terra.proto@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@classic-terra/terra.proto/-/terra.proto-1.1.0.tgz#e314d89f59b49e79a04db25f66f658e5e5aa1890" + integrity sha512-bYhQG5LUaGF0KPRY9hYT/HEcd1QExZPQd6zLV/rQkCe/eDxfwFRLzZHpaaAdfWoAAZjsRWqJbUCqCg7gXBbJpw== + dependencies: + "@improbable-eng/grpc-web" "^0.14.1" + google-protobuf "^3.17.3" + long "^4.0.0" + protobufjs "~6.11.2" + +"@confio/ics23@^0.6.8": + version "0.6.8" + resolved "https://registry.yarnpkg.com/@confio/ics23/-/ics23-0.6.8.tgz#2a6b4f1f2b7b20a35d9a0745bb5a446e72930b3d" + integrity sha512-wB6uo+3A50m0sW/EWcU64xpV/8wShZ6bMTa7pF8eYsTrSkQA7oLUIJcs/wb8g4y2Oyq701BaGiO6n/ak5WXO1w== + dependencies: + "@noble/hashes" "^1.0.0" + protobufjs "^6.8.8" + +"@coral-xyz/borsh@0.2.6": + version "0.2.6" + resolved "https://registry.yarnpkg.com/@coral-xyz/borsh/-/borsh-0.2.6.tgz#0f11b223bf2967574310705afd3c53ce26688ada" + integrity sha512-y6nmHw1bFcJib7sMHsQPpC8r47xhqDZVvhUdna7NUPzpSbOZG6f46N21+aXsQ2w/tG8Ggls488J/ZmwbgVmyjg== + dependencies: + bn.js "^5.1.2" + buffer-layout "^1.2.0" + +"@cosmjs/amino@^0.30.1": + version "0.30.1" + resolved "https://registry.yarnpkg.com/@cosmjs/amino/-/amino-0.30.1.tgz#7c18c14627361ba6c88e3495700ceea1f76baace" + integrity sha512-yNHnzmvAlkETDYIpeCTdVqgvrdt1qgkOXwuRVi8s27UKI5hfqyE9fJ/fuunXE6ZZPnKkjIecDznmuUOMrMvw4w== + dependencies: + "@cosmjs/crypto" "^0.30.1" + "@cosmjs/encoding" "^0.30.1" + "@cosmjs/math" "^0.30.1" + "@cosmjs/utils" "^0.30.1" + +"@cosmjs/crypto@^0.30.1": + version "0.30.1" + resolved "https://registry.yarnpkg.com/@cosmjs/crypto/-/crypto-0.30.1.tgz#21e94d5ca8f8ded16eee1389d2639cb5c43c3eb5" + integrity sha512-rAljUlake3MSXs9xAm87mu34GfBLN0h/1uPPV6jEwClWjNkAMotzjC0ab9MARy5FFAvYHL3lWb57bhkbt2GtzQ== + dependencies: + "@cosmjs/encoding" "^0.30.1" + "@cosmjs/math" "^0.30.1" + "@cosmjs/utils" "^0.30.1" + "@noble/hashes" "^1" + bn.js "^5.2.0" + elliptic "^6.5.4" + libsodium-wrappers "^0.7.6" + +"@cosmjs/encoding@^0.30.1": + version "0.30.1" + resolved "https://registry.yarnpkg.com/@cosmjs/encoding/-/encoding-0.30.1.tgz#b5c4e0ef7ceb1f2753688eb96400ed70f35c6058" + integrity sha512-rXmrTbgqwihORwJ3xYhIgQFfMSrwLu1s43RIK9I8EBudPx3KmnmyAKzMOVsRDo9edLFNuZ9GIvysUCwQfq3WlQ== + dependencies: + base64-js "^1.3.0" + bech32 "^1.1.4" + readonly-date "^1.0.0" + +"@cosmjs/json-rpc@^0.30.1": + version "0.30.1" + resolved "https://registry.yarnpkg.com/@cosmjs/json-rpc/-/json-rpc-0.30.1.tgz#16f21305fc167598c8a23a45549b85106b2372bc" + integrity sha512-pitfC/2YN9t+kXZCbNuyrZ6M8abnCC2n62m+JtU9vQUfaEtVsgy+1Fk4TRQ175+pIWSdBMFi2wT8FWVEE4RhxQ== + dependencies: + "@cosmjs/stream" "^0.30.1" + xstream "^11.14.0" + +"@cosmjs/math@^0.30.1": + version "0.30.1" + resolved "https://registry.yarnpkg.com/@cosmjs/math/-/math-0.30.1.tgz#8b816ef4de5d3afa66cb9fdfb5df2357a7845b8a" + integrity sha512-yaoeI23pin9ZiPHIisa6qqLngfnBR/25tSaWpkTm8Cy10MX70UF5oN4+/t1heLaM6SSmRrhk3psRkV4+7mH51Q== + dependencies: + bn.js "^5.2.0" + +"@cosmjs/proto-signing@^0.30.1": + version "0.30.1" + resolved "https://registry.yarnpkg.com/@cosmjs/proto-signing/-/proto-signing-0.30.1.tgz#f0dda372488df9cd2677150b89b3e9c72b3cb713" + integrity sha512-tXh8pPYXV4aiJVhTKHGyeZekjj+K9s2KKojMB93Gcob2DxUjfKapFYBMJSgfKPuWUPEmyr8Q9km2hplI38ILgQ== + dependencies: + "@cosmjs/amino" "^0.30.1" + "@cosmjs/crypto" "^0.30.1" + "@cosmjs/encoding" "^0.30.1" + "@cosmjs/math" "^0.30.1" + "@cosmjs/utils" "^0.30.1" + cosmjs-types "^0.7.1" + long "^4.0.0" + +"@cosmjs/socket@^0.30.1": + version "0.30.1" + resolved "https://registry.yarnpkg.com/@cosmjs/socket/-/socket-0.30.1.tgz#00b22f4b5e2ab01f4d82ccdb7b2e59536bfe5ce0" + integrity sha512-r6MpDL+9N+qOS/D5VaxnPaMJ3flwQ36G+vPvYJsXArj93BjgyFB7BwWwXCQDzZ+23cfChPUfhbINOenr8N2Kow== + dependencies: + "@cosmjs/stream" "^0.30.1" + isomorphic-ws "^4.0.1" + ws "^7" + xstream "^11.14.0" + +"@cosmjs/stargate@^0.30.1": + version "0.30.1" + resolved "https://registry.yarnpkg.com/@cosmjs/stargate/-/stargate-0.30.1.tgz#e1b22e1226cffc6e93914a410755f1f61057ba04" + integrity sha512-RdbYKZCGOH8gWebO7r6WvNnQMxHrNXInY/gPHPzMjbQF6UatA6fNM2G2tdgS5j5u7FTqlCI10stNXrknaNdzog== + dependencies: + "@confio/ics23" "^0.6.8" + "@cosmjs/amino" "^0.30.1" + "@cosmjs/encoding" "^0.30.1" + "@cosmjs/math" "^0.30.1" + "@cosmjs/proto-signing" "^0.30.1" + "@cosmjs/stream" "^0.30.1" + "@cosmjs/tendermint-rpc" "^0.30.1" + "@cosmjs/utils" "^0.30.1" + cosmjs-types "^0.7.1" + long "^4.0.0" + protobufjs "~6.11.3" + xstream "^11.14.0" + +"@cosmjs/stream@^0.30.1": + version "0.30.1" + resolved "https://registry.yarnpkg.com/@cosmjs/stream/-/stream-0.30.1.tgz#ba038a2aaf41343696b1e6e759d8e03a9516ec1a" + integrity sha512-Fg0pWz1zXQdoxQZpdHRMGvUH5RqS6tPv+j9Eh7Q953UjMlrwZVo0YFLC8OTf/HKVf10E4i0u6aM8D69Q6cNkgQ== + dependencies: + xstream "^11.14.0" + +"@cosmjs/tendermint-rpc@^0.30.1": + version "0.30.1" + resolved "https://registry.yarnpkg.com/@cosmjs/tendermint-rpc/-/tendermint-rpc-0.30.1.tgz#c16378892ba1ac63f72803fdf7567eab9d4f0aa0" + integrity sha512-Z3nCwhXSbPZJ++v85zHObeUggrEHVfm1u18ZRwXxFE9ZMl5mXTybnwYhczuYOl7KRskgwlB+rID0WYACxj4wdQ== + dependencies: + "@cosmjs/crypto" "^0.30.1" + "@cosmjs/encoding" "^0.30.1" + "@cosmjs/json-rpc" "^0.30.1" + "@cosmjs/math" "^0.30.1" + "@cosmjs/socket" "^0.30.1" + "@cosmjs/stream" "^0.30.1" + "@cosmjs/utils" "^0.30.1" + axios "^0.21.2" + readonly-date "^1.0.0" + xstream "^11.14.0" + +"@cosmjs/utils@^0.30.1": + version "0.30.1" + resolved "https://registry.yarnpkg.com/@cosmjs/utils/-/utils-0.30.1.tgz#6d92582341be3c2ec8d82090253cfa4b7f959edb" + integrity sha512-KvvX58MGMWh7xA+N+deCfunkA/ZNDvFLw4YbOmX3f/XBIkqrVY7qlotfy2aNb1kgp6h4B6Yc8YawJPDTfvWX7g== + +"@cspotcode/source-map-support@^0.8.0": + version "0.8.1" + resolved "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz" + integrity sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw== + dependencies: + "@jridgewell/trace-mapping" "0.3.9" + +"@ethereumjs/common@^2.6.4": + version "2.6.5" + resolved "https://registry.yarnpkg.com/@ethereumjs/common/-/common-2.6.5.tgz#0a75a22a046272579d91919cb12d84f2756e8d30" + integrity sha512-lRyVQOeCDaIVtgfbowla32pzeDv2Obr8oR8Put5RdUBNRGr1VGPGQNGP6elWIpgK3YdpzqTOh4GyUGOureVeeA== + dependencies: + crc-32 "^1.2.0" + ethereumjs-util "^7.1.5" + +"@ethereumjs/tx@3.5.2": + version "3.5.2" + resolved "https://registry.yarnpkg.com/@ethereumjs/tx/-/tx-3.5.2.tgz#197b9b6299582ad84f9527ca961466fce2296c1c" + integrity sha512-gQDNJWKrSDGu2w7w0PzVXVBNMzb7wwdDOmOqczmhNjqFxFuIbhVJDwiGEnxFNC2/b8ifcZzY7MLcluizohRzNw== + dependencies: + "@ethereumjs/common" "^2.6.4" + ethereumjs-util "^7.1.5" + +"@ethersproject/abi@5.7.0", "@ethersproject/abi@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/abi/-/abi-5.7.0.tgz" + integrity sha512-351ktp42TiRcYB3H1OP8yajPeAQstMW/yCFokj/AthP9bLHzQFPlOrxOcwYEDkUAICmOHljvN4K39OMTMUa9RA== + dependencies: + "@ethersproject/address" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/constants" "^5.7.0" + "@ethersproject/hash" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + +"@ethersproject/abstract-provider@5.7.0", "@ethersproject/abstract-provider@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/abstract-provider/-/abstract-provider-5.7.0.tgz" + integrity sha512-R41c9UkchKCpAqStMYUpdunjo3pkEvZC3FAwZn5S5MGbXoMQOHIdHItezTETxAO5bevtMApSyEhn9+CHcDsWBw== + dependencies: + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/networks" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/transactions" "^5.7.0" + "@ethersproject/web" "^5.7.0" + +"@ethersproject/abstract-signer@5.7.0", "@ethersproject/abstract-signer@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/abstract-signer/-/abstract-signer-5.7.0.tgz" + integrity sha512-a16V8bq1/Cz+TGCkE2OPMTOUDLS3grCpdjoJCYNnVBbdYEMSgKrU0+B90s8b6H+ByYTBZN7a3g76jdIJi7UfKQ== + dependencies: + "@ethersproject/abstract-provider" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + +"@ethersproject/address@5.7.0", "@ethersproject/address@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/address/-/address-5.7.0.tgz" + integrity sha512-9wYhYt7aghVGo758POM5nqcOMaE168Q6aRLJZwUmiqSrAungkG74gSSeKEIR7ukixesdRZGPgVqme6vmxs1fkA== + dependencies: + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/rlp" "^5.7.0" + +"@ethersproject/base64@5.7.0", "@ethersproject/base64@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/base64/-/base64-5.7.0.tgz" + integrity sha512-Dr8tcHt2mEbsZr/mwTPIQAf3Ai0Bks/7gTw9dSqk1mQvhW3XvRlmDJr/4n+wg1JmCl16NZue17CDh8xb/vZ0sQ== + dependencies: + "@ethersproject/bytes" "^5.7.0" + +"@ethersproject/basex@5.7.0", "@ethersproject/basex@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/basex/-/basex-5.7.0.tgz" + integrity sha512-ywlh43GwZLv2Voc2gQVTKBoVQ1mti3d8HK5aMxsfu/nRDnMmNqaSJ3r3n85HBByT8OpoY96SXM1FogC533T4zw== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + +"@ethersproject/bignumber@5.7.0", "@ethersproject/bignumber@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/bignumber/-/bignumber-5.7.0.tgz" + integrity sha512-n1CAdIHRWjSucQO3MC1zPSVgV/6dy/fjL9pMrPP9peL+QxEg9wOsVqwD4+818B6LUEtaXzVHQiuivzRoxPxUGw== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + bn.js "^5.2.1" + +"@ethersproject/bytes@5.7.0", "@ethersproject/bytes@^5.6.1", "@ethersproject/bytes@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/bytes/-/bytes-5.7.0.tgz" + integrity sha512-nsbxwgFXWh9NyYWo+U8atvmMsSdKJprTcICAkvbBffT75qDocbuggBU0SJiVK2MuTrp0q+xvLkTnGMPK1+uA9A== + dependencies: + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/constants@5.7.0", "@ethersproject/constants@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/constants/-/constants-5.7.0.tgz" + integrity sha512-DHI+y5dBNvkpYUMiRQyxRBYBefZkJfo70VUkUAsRjcPs47muV9evftfZ0PJVCXYbAiCgght0DtcF9srFQmIgWA== + dependencies: + "@ethersproject/bignumber" "^5.7.0" + +"@ethersproject/contracts@5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/contracts/-/contracts-5.7.0.tgz" + integrity sha512-5GJbzEU3X+d33CdfPhcyS+z8MzsTrBGk/sc+G+59+tPa9yFkl6HQ9D6L0QMgNTA9q8dT0XKxxkyp883XsQvbbg== + dependencies: + "@ethersproject/abi" "^5.7.0" + "@ethersproject/abstract-provider" "^5.7.0" + "@ethersproject/abstract-signer" "^5.7.0" + "@ethersproject/address" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/constants" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/transactions" "^5.7.0" + +"@ethersproject/hash@5.7.0", "@ethersproject/hash@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/hash/-/hash-5.7.0.tgz" + integrity sha512-qX5WrQfnah1EFnO5zJv1v46a8HW0+E5xuBBDTwMFZLuVTx0tbU2kkx15NqdjxecrLGatQN9FGQKpb1FKdHCt+g== + dependencies: + "@ethersproject/abstract-signer" "^5.7.0" + "@ethersproject/address" "^5.7.0" + "@ethersproject/base64" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + +"@ethersproject/hdnode@5.7.0", "@ethersproject/hdnode@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/hdnode/-/hdnode-5.7.0.tgz" + integrity sha512-OmyYo9EENBPPf4ERhR7oj6uAtUAhYGqOnIS+jE5pTXvdKBS99ikzq1E7Iv0ZQZ5V36Lqx1qZLeak0Ra16qpeOg== + dependencies: + "@ethersproject/abstract-signer" "^5.7.0" + "@ethersproject/basex" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/pbkdf2" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/sha2" "^5.7.0" + "@ethersproject/signing-key" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + "@ethersproject/transactions" "^5.7.0" + "@ethersproject/wordlists" "^5.7.0" + +"@ethersproject/json-wallets@5.7.0", "@ethersproject/json-wallets@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/json-wallets/-/json-wallets-5.7.0.tgz" + integrity sha512-8oee5Xgu6+RKgJTkvEMl2wDgSPSAQ9MB/3JYjFV9jlKvcYHUXZC+cQp0njgmxdHkYWn8s6/IqIZYm0YWCjO/0g== + dependencies: + "@ethersproject/abstract-signer" "^5.7.0" + "@ethersproject/address" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/hdnode" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/pbkdf2" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/random" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + "@ethersproject/transactions" "^5.7.0" + aes-js "3.0.0" + scrypt-js "3.0.1" + +"@ethersproject/keccak256@5.7.0", "@ethersproject/keccak256@^5.6.1", "@ethersproject/keccak256@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/keccak256/-/keccak256-5.7.0.tgz" + integrity sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg== + dependencies: + "@ethersproject/bytes" "^5.7.0" + js-sha3 "0.8.0" + +"@ethersproject/logger@5.7.0", "@ethersproject/logger@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/logger/-/logger-5.7.0.tgz" + integrity sha512-0odtFdXu/XHtjQXJYA3u9G0G8btm0ND5Cu8M7i5vhEcE8/HmF4Lbdqanwyv4uQTr2tx6b7fQRmgLrsnpQlmnig== + +"@ethersproject/networks@5.7.1", "@ethersproject/networks@^5.7.0": + version "5.7.1" + resolved "https://registry.npmjs.org/@ethersproject/networks/-/networks-5.7.1.tgz" + integrity sha512-n/MufjFYv3yFcUyfhnXotyDlNdFb7onmkSy8aQERi2PjNcnWQ66xXxa3XlS8nCcA8aJKJjIIMNJTC7tu80GwpQ== + dependencies: + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/pbkdf2@5.7.0", "@ethersproject/pbkdf2@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/pbkdf2/-/pbkdf2-5.7.0.tgz" + integrity sha512-oR/dBRZR6GTyaofd86DehG72hY6NpAjhabkhxgr3X2FpJtJuodEl2auADWBZfhDHgVCbu3/H/Ocq2uC6dpNjjw== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/sha2" "^5.7.0" + +"@ethersproject/properties@5.7.0", "@ethersproject/properties@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/properties/-/properties-5.7.0.tgz" + integrity sha512-J87jy8suntrAkIZtecpxEPxY//szqr1mlBaYlQ0r4RCaiD2hjheqF9s1LVE8vVuJCXisjIP+JgtK/Do54ej4Sw== + dependencies: + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/providers@5.7.2": + version "5.7.2" + resolved "https://registry.npmjs.org/@ethersproject/providers/-/providers-5.7.2.tgz" + integrity sha512-g34EWZ1WWAVgr4aptGlVBF8mhl3VWjv+8hoAnzStu8Ah22VHBsuGzP17eb6xDVRzw895G4W7vvx60lFFur/1Rg== + dependencies: + "@ethersproject/abstract-provider" "^5.7.0" + "@ethersproject/abstract-signer" "^5.7.0" + "@ethersproject/address" "^5.7.0" + "@ethersproject/base64" "^5.7.0" + "@ethersproject/basex" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/constants" "^5.7.0" + "@ethersproject/hash" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/networks" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/random" "^5.7.0" + "@ethersproject/rlp" "^5.7.0" + "@ethersproject/sha2" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + "@ethersproject/transactions" "^5.7.0" + "@ethersproject/web" "^5.7.0" + bech32 "1.1.4" + ws "7.4.6" + +"@ethersproject/random@5.7.0", "@ethersproject/random@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/random/-/random-5.7.0.tgz" + integrity sha512-19WjScqRA8IIeWclFme75VMXSBvi4e6InrUNuaR4s5pTF2qNhcGdCUwdxUVGtDDqC00sDLCO93jPQoDUH4HVmQ== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/rlp@5.7.0", "@ethersproject/rlp@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/rlp/-/rlp-5.7.0.tgz" + integrity sha512-rBxzX2vK8mVF7b0Tol44t5Tb8gomOHkj5guL+HhzQ1yBh/ydjGnpw6at+X6Iw0Kp3OzzzkcKp8N9r0W4kYSs9w== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/sha2@5.7.0", "@ethersproject/sha2@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/sha2/-/sha2-5.7.0.tgz" + integrity sha512-gKlH42riwb3KYp0reLsFTokByAKoJdgFCwI+CCiX/k+Jm2mbNs6oOaCjYQSlI1+XBVejwH2KrmCbMAT/GnRDQw== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + hash.js "1.1.7" + +"@ethersproject/signing-key@5.7.0", "@ethersproject/signing-key@^5.6.2", "@ethersproject/signing-key@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/signing-key/-/signing-key-5.7.0.tgz" + integrity sha512-MZdy2nL3wO0u7gkB4nA/pEf8lu1TlFswPNmy8AiYkfKTdO6eXBJyUdmHO/ehm/htHw9K/qF8ujnTyUAD+Ry54Q== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + bn.js "^5.2.1" + elliptic "6.5.4" + hash.js "1.1.7" + +"@ethersproject/solidity@5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/solidity/-/solidity-5.7.0.tgz" + integrity sha512-HmabMd2Dt/raavyaGukF4XxizWKhKQ24DoLtdNbBmNKUOPqwjsKQSdV9GQtj9CBEea9DlzETlVER1gYeXXBGaA== + dependencies: + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/sha2" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + +"@ethersproject/strings@5.7.0", "@ethersproject/strings@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/strings/-/strings-5.7.0.tgz" + integrity sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/constants" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/transactions@5.7.0", "@ethersproject/transactions@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/transactions/-/transactions-5.7.0.tgz" + integrity sha512-kmcNicCp1lp8qanMTC3RIikGgoJ80ztTyvtsFvCYpSCfkjhD0jZ2LOrnbcuxuToLIUYYf+4XwD1rP+B/erDIhQ== + dependencies: + "@ethersproject/address" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/constants" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/rlp" "^5.7.0" + "@ethersproject/signing-key" "^5.7.0" + +"@ethersproject/units@5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/units/-/units-5.7.0.tgz" + integrity sha512-pD3xLMy3SJu9kG5xDGI7+xhTEmGXlEqXU4OfNapmfnxLVY4EMSSRp7j1k7eezutBPH7RBN/7QPnwR7hzNlEFeg== + dependencies: + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/constants" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + +"@ethersproject/wallet@5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/wallet/-/wallet-5.7.0.tgz" + integrity sha512-MhmXlJXEJFBFVKrDLB4ZdDzxcBxQ3rLyCkhNqVu3CDYvR97E+8r01UgrI+TI99Le+aYm/in/0vp86guJuM7FCA== + dependencies: + "@ethersproject/abstract-provider" "^5.7.0" + "@ethersproject/abstract-signer" "^5.7.0" + "@ethersproject/address" "^5.7.0" + "@ethersproject/bignumber" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/hash" "^5.7.0" + "@ethersproject/hdnode" "^5.7.0" + "@ethersproject/json-wallets" "^5.7.0" + "@ethersproject/keccak256" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/random" "^5.7.0" + "@ethersproject/signing-key" "^5.7.0" + "@ethersproject/transactions" "^5.7.0" + "@ethersproject/wordlists" "^5.7.0" + +"@ethersproject/web@5.7.1", "@ethersproject/web@^5.7.0": + version "5.7.1" + resolved "https://registry.npmjs.org/@ethersproject/web/-/web-5.7.1.tgz" + integrity sha512-Gueu8lSvyjBWL4cYsWsjh6MtMwM0+H4HvqFPZfB6dV8ctbP9zFAO73VG1cMWae0FLPCtz0peKPpZY8/ugJJX2w== + dependencies: + "@ethersproject/base64" "^5.7.0" + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + +"@ethersproject/wordlists@5.7.0", "@ethersproject/wordlists@^5.7.0": + version "5.7.0" + resolved "https://registry.npmjs.org/@ethersproject/wordlists/-/wordlists-5.7.0.tgz" + integrity sha512-S2TFNJNfHWVHNE6cNDjbVlZ6MgE17MIxMbMg2zv3wn+3XSJGosL1m9ZVv3GXCf/2ymSsQ+hRI5IzoMJTG6aoVA== + dependencies: + "@ethersproject/bytes" "^5.7.0" + "@ethersproject/hash" "^5.7.0" + "@ethersproject/logger" "^5.7.0" + "@ethersproject/properties" "^5.7.0" + "@ethersproject/strings" "^5.7.0" + +"@graphql-typed-document-node/core@^3.1.1": + version "3.2.0" + resolved "https://registry.yarnpkg.com/@graphql-typed-document-node/core/-/core-3.2.0.tgz#5f3d96ec6b2354ad6d8a28bf216a1d97b5426861" + integrity sha512-mB9oAsNCm9aM3/SOv4YtBMqZbYj10R7dkq8byBqxGY/ncFwhf2oQzMV+LCRlWoDSEBJ3COiR1yeDvMtsoOsuFQ== + +"@improbable-eng/grpc-web@^0.14.1": + version "0.14.1" + resolved "https://registry.yarnpkg.com/@improbable-eng/grpc-web/-/grpc-web-0.14.1.tgz#f4662f64dc89c0f956a94bb8a3b576556c74589c" + integrity sha512-XaIYuunepPxoiGVLLHmlnVminUGzBTnXr8Wv7khzmLWbNw4TCwJKX09GSMJlKhu/TRk6gms0ySFxewaETSBqgw== + dependencies: + browser-headers "^0.4.1" + +"@improbable-eng/grpc-web@^0.15.0": + version "0.15.0" + resolved "https://registry.yarnpkg.com/@improbable-eng/grpc-web/-/grpc-web-0.15.0.tgz#3e47e9fdd90381a74abd4b7d26e67422a2a04bef" + integrity sha512-ERft9/0/8CmYalqOVnJnpdDry28q+j+nAlFFARdjyxXDJ+Mhgv9+F600QC8BR9ygOfrXRlAk6CvST2j+JCpQPg== + dependencies: + browser-headers "^0.4.1" + +"@injectivelabs/core-proto-ts@^0.0.12": + version "0.0.12" + resolved "https://registry.yarnpkg.com/@injectivelabs/core-proto-ts/-/core-proto-ts-0.0.12.tgz#77dd5e774ed2591f6f41156db33a281a3522c588" + integrity sha512-axdL+KWuv4aORIdYqJQy5k9H+bPsi5Y4KWNcYPxrFQ0FAu+sjpvm5PmbIzBSgv/hnIB2cHcLuKvE3BtEa3vJ/w== + dependencies: + "@injectivelabs/grpc-web" "^0.0.1" + google-protobuf "^3.14.0" + protobufjs "^7.0.0" + rxjs "^7.4.0" + +"@injectivelabs/exceptions@^1.10.12", "@injectivelabs/exceptions@^1.10.5": + version "1.10.12" + resolved "https://registry.yarnpkg.com/@injectivelabs/exceptions/-/exceptions-1.10.12.tgz#b3855a0a0feb8e4ebe9adb8554e2d1fc934c74d1" + integrity sha512-9x8WDRi/K6JRMRAGJblbS0wQKckIX69CPU61ea22RprkO0sPazxpzp56txgHj0uHYkq2bg/exrX8N6UxdrNCMg== + dependencies: + "@injectivelabs/grpc-web" "^0.0.1" + "@injectivelabs/ts-types" "^1.10.12" + http-status-codes "^2.2.0" + link-module-alias "^1.2.0" + shx "^0.3.2" + +"@injectivelabs/grpc-web-node-http-transport@^0.0.2": + version "0.0.2" + resolved "https://registry.yarnpkg.com/@injectivelabs/grpc-web-node-http-transport/-/grpc-web-node-http-transport-0.0.2.tgz#87c9bbd4db1f70cf18d6a55b54b2cf17d3cf30c0" + integrity sha512-rpyhXLiGY/UMs6v6YmgWHJHiO9l0AgDyVNv+jcutNVt4tQrmNvnpvz2wCAGOFtq5LuX/E9ChtTVpk3gWGqXcGA== + +"@injectivelabs/grpc-web-react-native-transport@^0.0.2": + version "0.0.2" + resolved "https://registry.yarnpkg.com/@injectivelabs/grpc-web-react-native-transport/-/grpc-web-react-native-transport-0.0.2.tgz#07601b76bf1f165c7a9b97ee42d0d42b9e2b76fa" + integrity sha512-mk+aukQXnYNgPsPnu3KBi+FD0ZHQpazIlaBZ2jNZG7QAVmxTWtv3R66Zoq99Wx2dnE946NsZBYAoa0K5oSjnow== + +"@injectivelabs/grpc-web@^0.0.1": + version "0.0.1" + resolved "https://registry.yarnpkg.com/@injectivelabs/grpc-web/-/grpc-web-0.0.1.tgz#24c028f6db50e589e30505efd2077110c8b492ba" + integrity sha512-Pu5YgaZp+OvR5UWfqbrPdHer3+gDf+b5fQoY+t2VZx1IAVHX8bzbN9EreYTvTYtFeDpYRWM8P7app2u4EX5wTw== + dependencies: + browser-headers "^0.4.1" + +"@injectivelabs/indexer-proto-ts@1.10.8-rc.4": + version "1.10.8-rc.4" + resolved "https://registry.yarnpkg.com/@injectivelabs/indexer-proto-ts/-/indexer-proto-ts-1.10.8-rc.4.tgz#ab8424cd713bb5a69ab130b64bf0b3f9f9089946" + integrity sha512-IwbepTfsHHAv3Z36As6yH/+HIplOEpUu6SFHBCVgdSIaQ8GuvTib4HETiVnV4mjYqoyVgWs+zLSAfih46rdMJQ== + dependencies: + "@injectivelabs/grpc-web" "^0.0.1" + google-protobuf "^3.14.0" + protobufjs "^7.0.0" + rxjs "^7.4.0" + +"@injectivelabs/mito-proto-ts@1.0.4": + version "1.0.4" + resolved "https://registry.yarnpkg.com/@injectivelabs/mito-proto-ts/-/mito-proto-ts-1.0.4.tgz#788146b5b0194fb5df91b903fa982a70427194a5" + integrity sha512-8raVmZnaXVbpikMTmnc+OtViBPzgyx2ilezUTZFCNcQzZM01lbJlpd0NbF6K5tG76eJ3Wjwj+YpAdRPNuayZ4A== + dependencies: + "@injectivelabs/grpc-web" "^0.0.1" + google-protobuf "^3.14.0" + protobufjs "^7.0.0" + rxjs "^7.4.0" + +"@injectivelabs/networks@1.10.7": + version "1.10.7" + resolved "https://registry.yarnpkg.com/@injectivelabs/networks/-/networks-1.10.7.tgz#34d16414dd77f49639e579a69bbab1990a0eef9c" + integrity sha512-qnU3A7FgTVi4bGEMaSsSIN2wTBhKZfV+3fiwU09aX8ZNcWAilMx8d/mlE1naZFAHs7Kf5hFBxzgeSRZa1GJqiA== + dependencies: + "@injectivelabs/exceptions" "^1.10.5" + "@injectivelabs/ts-types" "^1.10.4" + "@injectivelabs/utils" "^1.10.5" + link-module-alias "^1.2.0" + shx "^0.3.2" + +"@injectivelabs/networks@^1.10.12", "@injectivelabs/networks@^1.10.7": + version "1.10.12" + resolved "https://registry.yarnpkg.com/@injectivelabs/networks/-/networks-1.10.12.tgz#8c3fcf96a8930c28dcd44d779e1ef31e68ec7b0b" + integrity sha512-tTHyLls1Nik5QTs/S03qqG2y/ITvNwI8CJOQbMmmsr1CL2CdjJBtzRYn9Dyx2p8XgzRFf9hmlybpe20tq9O3SA== + dependencies: + "@injectivelabs/exceptions" "^1.10.12" + "@injectivelabs/ts-types" "^1.10.12" + "@injectivelabs/utils" "^1.10.12" + link-module-alias "^1.2.0" + shx "^0.3.2" + +"@injectivelabs/sdk-ts@1.10.47": + version "1.10.47" + resolved "https://registry.yarnpkg.com/@injectivelabs/sdk-ts/-/sdk-ts-1.10.47.tgz#9f2beca13b005a451551ee5f7c003e7bf92f9a74" + integrity sha512-G11Cdf5iO6is0qWzQRdfiUJLI8IPF4VtD5mVfBwnakrk78syN/Dy492trL7hispDSQaCJaP6a/fa6HnMPCsvzA== + dependencies: + "@apollo/client" "^3.5.8" + "@cosmjs/amino" "^0.30.1" + "@cosmjs/proto-signing" "^0.30.1" + "@cosmjs/stargate" "^0.30.1" + "@ethersproject/bytes" "^5.7.0" + "@injectivelabs/core-proto-ts" "^0.0.12" + "@injectivelabs/exceptions" "^1.10.5" + "@injectivelabs/grpc-web" "^0.0.1" + "@injectivelabs/grpc-web-node-http-transport" "^0.0.2" + "@injectivelabs/grpc-web-react-native-transport" "^0.0.2" + "@injectivelabs/indexer-proto-ts" "1.10.8-rc.4" + "@injectivelabs/mito-proto-ts" "1.0.4" + "@injectivelabs/networks" "^1.10.7" + "@injectivelabs/test-utils" "^1.10.2" + "@injectivelabs/token-metadata" "^1.10.25" + "@injectivelabs/ts-types" "^1.10.4" + "@injectivelabs/utils" "^1.10.5" + "@metamask/eth-sig-util" "^4.0.0" + axios "^0.27.2" + bech32 "^2.0.0" + bip39 "^3.0.4" + cosmjs-types "^0.7.1" + eth-crypto "^2.6.0" + ethereumjs-util "^7.1.4" + ethers "^5.7.2" + google-protobuf "^3.21.0" + graphql "^16.3.0" + http-status-codes "^2.2.0" + js-sha3 "^0.8.0" + jscrypto "^1.0.3" + keccak256 "^1.0.6" + link-module-alias "^1.2.0" + rxjs "^7.8.0" + secp256k1 "^4.0.3" + shx "^0.3.2" + snakecase-keys "^5.4.1" + +"@injectivelabs/test-utils@^1.10.2": + version "1.10.12" + resolved "https://registry.yarnpkg.com/@injectivelabs/test-utils/-/test-utils-1.10.12.tgz#da2234b73547a409d2c21ad4cc0e2eac02894f4f" + integrity sha512-IFqlEeFXXf6V1NEt65W2SfAN5/73lK4BmTrfeOQANfOFa3TUAJcPuU8rhx4jhi801cZLV3R9D/iQdgE1tbUK9A== + dependencies: + axios "^0.21.1" + bignumber.js "^9.0.1" + link-module-alias "^1.2.0" + shx "^0.3.2" + snakecase-keys "^5.1.2" + store2 "^2.12.0" + +"@injectivelabs/token-metadata@^1.10.25": + version "1.10.42" + resolved "https://registry.yarnpkg.com/@injectivelabs/token-metadata/-/token-metadata-1.10.42.tgz#f3576f1f5381be5f0abeb1958b837f087ba0f95b" + integrity sha512-j5S+f05/Xtcqbg7pPHRI6hjJpdjIIuMHo16nLecU86mEHhXOzdJzhi/yzrtW7dstlgshyUJKRPZ7HaiOvZNrjA== + dependencies: + "@injectivelabs/exceptions" "^1.10.12" + "@injectivelabs/networks" "^1.10.12" + "@injectivelabs/ts-types" "^1.10.12" + "@injectivelabs/utils" "^1.10.12" + "@types/lodash.values" "^4.3.6" + copyfiles "^2.4.1" + jsonschema "^1.4.0" + link-module-alias "^1.2.0" + lodash "^4.17.21" + lodash.values "^4.3.0" + shx "^0.3.2" + +"@injectivelabs/ts-types@^1.10.12", "@injectivelabs/ts-types@^1.10.4": + version "1.10.12" + resolved "https://registry.yarnpkg.com/@injectivelabs/ts-types/-/ts-types-1.10.12.tgz#24c38db74e3536c5a1b5f5e14c4307ffca2ff589" + integrity sha512-Z/qeZ9jwhqpreXFNiox6NrXLiMyhvMEd79RWMZ9lVOLjTeXRTUh/Vl7ry7KBE2OypsPPTMUP+k7Dhsn0ufFwgw== + dependencies: + link-module-alias "^1.2.0" + shx "^0.3.2" + +"@injectivelabs/utils@1.10.5": + version "1.10.5" + resolved "https://registry.yarnpkg.com/@injectivelabs/utils/-/utils-1.10.5.tgz#ea3f9f809c64b60f62e419f08b9a5ddb3bc35d7b" + integrity sha512-9t+9xOh8wQWs/kuUrfWjGAJMVbtgwu20AWdDQl5qeoNxstE7uKTM0hJWCn+OhF5WYloZH7kwfqEUSNZ84G/VpA== + dependencies: + "@injectivelabs/exceptions" "^1.10.5" + "@injectivelabs/ts-types" "^1.10.4" + axios "^0.21.1" + bignumber.js "^9.0.1" + http-status-codes "^2.2.0" + link-module-alias "^1.2.0" + shx "^0.3.2" + snakecase-keys "^5.1.2" + store2 "^2.12.0" + +"@injectivelabs/utils@^1.10.12", "@injectivelabs/utils@^1.10.5": + version "1.10.12" + resolved "https://registry.yarnpkg.com/@injectivelabs/utils/-/utils-1.10.12.tgz#063835b25c11182945881e82a2cbad50f6ca10b3" + integrity sha512-c8al79nxIJgV1cBAdW2TPDGldj/8gm5k0h5TIN/AJs8/AeIjpTwwVGfLY3QvPOpRsxuQ9CjBkTXrAcSL1wwkcw== + dependencies: + "@injectivelabs/exceptions" "^1.10.12" + "@injectivelabs/ts-types" "^1.10.12" + axios "^0.21.1" + bignumber.js "^9.0.1" + http-status-codes "^2.2.0" + link-module-alias "^1.2.0" + shx "^0.3.2" + snakecase-keys "^5.1.2" + store2 "^2.12.0" + +"@jridgewell/resolve-uri@^3.0.3": + version "3.1.0" + resolved "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz" + integrity sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w== + +"@jridgewell/sourcemap-codec@^1.4.10": + version "1.4.14" + resolved "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz" + integrity sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw== + +"@jridgewell/trace-mapping@0.3.9": + version "0.3.9" + resolved "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz" + integrity sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ== + dependencies: + "@jridgewell/resolve-uri" "^3.0.3" + "@jridgewell/sourcemap-codec" "^1.4.10" + +"@metamask/eth-sig-util@^4.0.0": + version "4.0.1" + resolved "https://registry.yarnpkg.com/@metamask/eth-sig-util/-/eth-sig-util-4.0.1.tgz#3ad61f6ea9ad73ba5b19db780d40d9aae5157088" + integrity sha512-tghyZKLHZjcdlDqCA3gNZmLeR0XvOE9U1qoQO9ohyAZT6Pya+H9vkBPcsyXytmYLNgVoin7CKCmweo/R43V+tQ== + dependencies: + ethereumjs-abi "^0.6.8" + ethereumjs-util "^6.2.1" + ethjs-util "^0.1.6" + tweetnacl "^1.0.3" + tweetnacl-util "^0.15.1" + +"@mysten/bcs@0.7.1": + version "0.7.1" + resolved "https://registry.npmjs.org/@mysten/bcs/-/bcs-0.7.1.tgz" + integrity sha512-wFPb8bkhwrbiStfZMV5rFM7J+umpke59/dNjDp+UYJKykNlW23LCk2ePyEUvGdb62HGJM1jyOJ8g4egE3OmdKA== + dependencies: + bs58 "^5.0.0" + +"@mysten/sui.js@0.32.2", "@mysten/sui.js@^0.32.2": + version "0.32.2" + resolved "https://registry.npmjs.org/@mysten/sui.js/-/sui.js-0.32.2.tgz" + integrity sha512-/Hm4xkGolJhqj8FvQr7QSHDTlxIvL52mtbOao9f75YjrBh7y1Uh9kbJSY7xiTF1NY9sv6p5hUVlYRJuM0Hvn9A== + dependencies: + "@mysten/bcs" "0.7.1" + "@noble/curves" "^1.0.0" + "@noble/hashes" "^1.3.0" + "@scure/bip32" "^1.3.0" + "@scure/bip39" "^1.2.0" + "@suchipi/femver" "^1.0.0" + jayson "^4.0.0" + rpc-websockets "^7.5.1" + superstruct "^1.0.3" + tweetnacl "^1.0.3" + +"@noble/curves@^1.0.0", "@noble/curves@~1.0.0": + version "1.0.0" + resolved "https://registry.npmjs.org/@noble/curves/-/curves-1.0.0.tgz" + integrity sha512-2upgEu0iLiDVDZkNLeFV2+ht0BAVgQnEmCk6JsOch9Rp8xfkMCbvbAZlA2pBHQc73dbl+vFOXfqkf4uemdn0bw== + dependencies: + "@noble/hashes" "1.3.0" + +"@noble/ed25519@^1.7.0": + version "1.7.3" + resolved "https://registry.yarnpkg.com/@noble/ed25519/-/ed25519-1.7.3.tgz#57e1677bf6885354b466c38e2b620c62f45a7123" + integrity sha512-iR8GBkDt0Q3GyaVcIu7mSsVIqnFbkbRzGLWlvhwunacoLwt4J3swfKhfaM6rN6WY+TBGoYT1GtT1mIh2/jGbRQ== + +"@noble/hashes@1.1.3": + version "1.1.3" + resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-1.1.3.tgz#360afc77610e0a61f3417e497dcf36862e4f8111" + integrity sha512-CE0FCR57H2acVI5UOzIGSSIYxZ6v/HOhDR0Ro9VLyhnzLwx0o8W1mmgaqlEUx4049qJDlIBRztv5k+MM8vbO3A== + +"@noble/hashes@1.3.0", "@noble/hashes@^1", "@noble/hashes@^1.0.0", "@noble/hashes@^1.1.2", "@noble/hashes@^1.2.0", "@noble/hashes@^1.3.0", "@noble/hashes@~1.3.0": + version "1.3.0" + resolved "https://registry.npmjs.org/@noble/hashes/-/hashes-1.3.0.tgz" + integrity sha512-ilHEACi9DwqJB0pw7kv+Apvh50jiiSyR/cQ3y4W7lOR5mhvn/50FLUfsnfJz0BDZtl/RR16kXvptiv6q1msYZg== + +"@noble/hashes@~1.1.1": + version "1.1.5" + resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-1.1.5.tgz#1a0377f3b9020efe2fae03290bd2a12140c95c11" + integrity sha512-LTMZiiLc+V4v1Yi16TD6aX2gmtKszNye0pQgbaLqkvhIqP7nVsSaJsWloGQjJfJ8offaoP5GtX3yY5swbcJxxQ== + +"@noble/secp256k1@^1.6.3": + version "1.7.1" + resolved "https://registry.yarnpkg.com/@noble/secp256k1/-/secp256k1-1.7.1.tgz#b251c70f824ce3ca7f8dc3df08d58f005cc0507c" + integrity sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw== + +"@project-serum/anchor@^0.25.0": + version "0.25.0" + resolved "https://registry.yarnpkg.com/@project-serum/anchor/-/anchor-0.25.0.tgz#88ee4843336005cf5a64c80636ce626f0996f503" + integrity sha512-E6A5Y/ijqpfMJ5psJvbw0kVTzLZFUcOFgs6eSM2M2iWE1lVRF18T6hWZVNl6zqZsoz98jgnNHtVGJMs+ds9A7A== + dependencies: + "@project-serum/borsh" "^0.2.5" + "@solana/web3.js" "^1.36.0" + base64-js "^1.5.1" + bn.js "^5.1.2" + bs58 "^4.0.1" + buffer-layout "^1.2.2" + camelcase "^5.3.1" + cross-fetch "^3.1.5" + crypto-hash "^1.3.0" + eventemitter3 "^4.0.7" + js-sha256 "^0.9.0" + pako "^2.0.3" + snake-case "^3.0.4" + superstruct "^0.15.4" + toml "^3.0.0" + +"@project-serum/borsh@^0.2.5": + version "0.2.5" + resolved "https://registry.yarnpkg.com/@project-serum/borsh/-/borsh-0.2.5.tgz#6059287aa624ecebbfc0edd35e4c28ff987d8663" + integrity sha512-UmeUkUoKdQ7rhx6Leve1SssMR/Ghv8qrEiyywyxSWg7ooV7StdpPBhciiy5eB3T0qU1BXvdRNC8TdrkxK7WC5Q== + dependencies: + bn.js "^5.1.2" + buffer-layout "^1.2.0" + +"@protobufjs/aspromise@^1.1.1", "@protobufjs/aspromise@^1.1.2": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@protobufjs/aspromise/-/aspromise-1.1.2.tgz#9b8b0cc663d669a7d8f6f5d0893a14d348f30fbf" + integrity sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ== + +"@protobufjs/base64@^1.1.2": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@protobufjs/base64/-/base64-1.1.2.tgz#4c85730e59b9a1f1f349047dbf24296034bb2735" + integrity sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg== + +"@protobufjs/codegen@^2.0.4": + version "2.0.4" + resolved "https://registry.yarnpkg.com/@protobufjs/codegen/-/codegen-2.0.4.tgz#7ef37f0d010fb028ad1ad59722e506d9262815cb" + integrity sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg== + +"@protobufjs/eventemitter@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz#355cbc98bafad5978f9ed095f397621f1d066b70" + integrity sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q== + +"@protobufjs/fetch@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/fetch/-/fetch-1.1.0.tgz#ba99fb598614af65700c1619ff06d454b0d84c45" + integrity sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ== + dependencies: + "@protobufjs/aspromise" "^1.1.1" + "@protobufjs/inquire" "^1.1.0" + +"@protobufjs/float@^1.0.2": + version "1.0.2" + resolved "https://registry.yarnpkg.com/@protobufjs/float/-/float-1.0.2.tgz#5e9e1abdcb73fc0a7cb8b291df78c8cbd97b87d1" + integrity sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ== + +"@protobufjs/inquire@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/inquire/-/inquire-1.1.0.tgz#ff200e3e7cf2429e2dcafc1140828e8cc638f089" + integrity sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q== + +"@protobufjs/path@^1.1.2": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@protobufjs/path/-/path-1.1.2.tgz#6cc2b20c5c9ad6ad0dccfd21ca7673d8d7fbf68d" + integrity sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA== + +"@protobufjs/pool@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/pool/-/pool-1.1.0.tgz#09fd15f2d6d3abfa9b65bc366506d6ad7846ff54" + integrity sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw== + +"@protobufjs/utf8@^1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@protobufjs/utf8/-/utf8-1.1.0.tgz#a777360b5b39a1a2e5106f8e858f2fd2d060c570" + integrity sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw== + +"@scure/base@~1.1.0": + version "1.1.1" + resolved "https://registry.npmjs.org/@scure/base/-/base-1.1.1.tgz" + integrity sha512-ZxOhsSyxYwLJj3pLZCefNitxsj093tb2vq90mp2txoYeBqbcjDjqFhyM8eUjq/uFm6zJ+mUuqxlS2FkuSY1MTA== + +"@scure/bip32@^1.3.0": + version "1.3.0" + resolved "https://registry.npmjs.org/@scure/bip32/-/bip32-1.3.0.tgz" + integrity sha512-bcKpo1oj54hGholplGLpqPHRbIsnbixFtc06nwuNM5/dwSXOq/AAYoIBRsBmnZJSdfeNW5rnff7NTAz3ZCqR9Q== + dependencies: + "@noble/curves" "~1.0.0" + "@noble/hashes" "~1.3.0" + "@scure/base" "~1.1.0" + +"@scure/bip39@1.1.0": + version "1.1.0" + resolved "https://registry.yarnpkg.com/@scure/bip39/-/bip39-1.1.0.tgz#92f11d095bae025f166bef3defcc5bf4945d419a" + integrity sha512-pwrPOS16VeTKg98dYXQyIjJEcWfz7/1YJIwxUEPFfQPtc86Ym/1sVgQ2RLoD43AazMk2l/unK4ITySSpW2+82w== + dependencies: + "@noble/hashes" "~1.1.1" + "@scure/base" "~1.1.0" + +"@scure/bip39@^1.2.0": + version "1.2.0" + resolved "https://registry.npmjs.org/@scure/bip39/-/bip39-1.2.0.tgz" + integrity sha512-SX/uKq52cuxm4YFXWFaVByaSHJh2w3BnokVSeUJVCv6K7WulT9u2BuNRBhuFl8vAuYnzx9bEu9WgpcNYTrYieg== + dependencies: + "@noble/hashes" "~1.3.0" + "@scure/base" "~1.1.0" + +"@solana/buffer-layout-utils@^0.2.0": + version "0.2.0" + resolved "https://registry.yarnpkg.com/@solana/buffer-layout-utils/-/buffer-layout-utils-0.2.0.tgz#b45a6cab3293a2eb7597cceb474f229889d875ca" + integrity sha512-szG4sxgJGktbuZYDg2FfNmkMi0DYQoVjN2h7ta1W1hPrwzarcFLBq9UpX1UjNXsNpT9dn+chgprtWGioUAr4/g== + dependencies: + "@solana/buffer-layout" "^4.0.0" + "@solana/web3.js" "^1.32.0" + bigint-buffer "^1.1.5" + bignumber.js "^9.0.1" + +"@solana/buffer-layout@^4.0.0": + version "4.0.1" + resolved "https://registry.yarnpkg.com/@solana/buffer-layout/-/buffer-layout-4.0.1.tgz#b996235eaec15b1e0b5092a8ed6028df77fa6c15" + integrity sha512-E1ImOIAD1tBZFRdjeM4/pzTiTApC0AOBGwyAMS4fwIodCWArzJ3DWdoh8cKxeFM2fElkxBh2Aqts1BPC373rHA== + dependencies: + buffer "~6.0.3" + +"@solana/spl-token@^0.3.5": + version "0.3.7" + resolved "https://registry.yarnpkg.com/@solana/spl-token/-/spl-token-0.3.7.tgz#6f027f9ad8e841f792c32e50920d9d2e714fc8da" + integrity sha512-bKGxWTtIw6VDdCBngjtsGlKGLSmiu/8ghSt/IOYJV24BsymRbgq7r12GToeetpxmPaZYLddKwAz7+EwprLfkfg== + dependencies: + "@solana/buffer-layout" "^4.0.0" + "@solana/buffer-layout-utils" "^0.2.0" + buffer "^6.0.3" + +"@solana/web3.js@^1.32.0", "@solana/web3.js@^1.36.0", "@solana/web3.js@^1.66.2": + version "1.75.0" + resolved "https://registry.yarnpkg.com/@solana/web3.js/-/web3.js-1.75.0.tgz#824c6f78865007bca758ca18f268d6f7363b42e5" + integrity sha512-rHQgdo1EWfb+nPUpHe4O7i8qJPELHKNR5PAZRK+a7XxiykqOfbaAlPt5boDWAGPnYbSv0ziWZv5mq9DlFaQCxg== + dependencies: + "@babel/runtime" "^7.12.5" + "@noble/ed25519" "^1.7.0" + "@noble/hashes" "^1.1.2" + "@noble/secp256k1" "^1.6.3" + "@solana/buffer-layout" "^4.0.0" + agentkeepalive "^4.2.1" + bigint-buffer "^1.1.5" + bn.js "^5.0.0" + borsh "^0.7.0" + bs58 "^4.0.1" + buffer "6.0.3" + fast-stable-stringify "^1.0.0" + jayson "^3.4.4" + node-fetch "^2.6.7" + rpc-websockets "^7.5.1" + superstruct "^0.14.2" + +"@suchipi/femver@^1.0.0": + version "1.0.0" + resolved "https://registry.npmjs.org/@suchipi/femver/-/femver-1.0.0.tgz" + integrity sha512-bprE8+K5V+DPX7q2e2K57ImqNBdfGHDIWaGI5xHxZoxbKOuQZn4wzPiUxOAHnsUr3w3xHrWXwN7gnG/iIuEMIg== + +"@terra-money/legacy.proto@npm:@terra-money/terra.proto@^0.1.7": + version "0.1.7" + resolved "https://registry.yarnpkg.com/@terra-money/terra.proto/-/terra.proto-0.1.7.tgz#59c18f30da10d43200bab3ba8feb5b17e43a365f" + integrity sha512-NXD7f6pQCulvo6+mv6MAPzhOkUzRjgYVuHZE/apih+lVnPG5hDBU0rRYnOGGofwvKT5/jQoOENnFn/gioWWnyQ== + dependencies: + google-protobuf "^3.17.3" + long "^4.0.0" + protobufjs "~6.11.2" + +"@terra-money/terra.js@^3.1.3": + version "3.1.8" + resolved "https://registry.yarnpkg.com/@terra-money/terra.js/-/terra.js-3.1.8.tgz#71525703cb04d863c549e13fc56cc81e508e85f0" + integrity sha512-Cd/fh4MswT00fDGVckoZ0cm77EpIy4+CjSDO0RqZ3Qfp4CJBp7sWTLRNsyzUWjdYOT5iTx+1wOMCYbbyKo6LAw== + dependencies: + "@classic-terra/terra.proto" "^1.1.0" + "@terra-money/terra.proto" "^2.1.0" + axios "^0.27.2" + bech32 "^2.0.0" + bip32 "^2.0.6" + bip39 "^3.0.3" + bufferutil "^4.0.3" + decimal.js "^10.2.1" + jscrypto "^1.0.1" + readable-stream "^3.6.0" + secp256k1 "^4.0.2" + tmp "^0.2.1" + utf-8-validate "^5.0.5" + ws "^7.5.9" + +"@terra-money/terra.proto@^2.1.0": + version "2.1.0" + resolved "https://registry.yarnpkg.com/@terra-money/terra.proto/-/terra.proto-2.1.0.tgz#5a2ed85fc8146a346d6095adfc5d205b6fb6d387" + integrity sha512-rhaMslv3Rkr+QsTQEZs64FKA4QlfO0DfQHaR6yct/EovenMkibDEQ63dEL6yJA6LCaEQGYhyVB9JO9pTUA8ybw== + dependencies: + "@improbable-eng/grpc-web" "^0.14.1" + google-protobuf "^3.17.3" + long "^4.0.0" + protobufjs "~6.11.2" + +"@tsconfig/node10@^1.0.7": + version "1.0.9" + resolved "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.9.tgz" + integrity sha512-jNsYVVxU8v5g43Erja32laIDHXeoNvFEpX33OK4d6hljo3jDhCBDhx5dhCCTMWUojscpAagGiRkBKxpdl9fxqA== + +"@tsconfig/node12@^1.0.7": + version "1.0.11" + resolved "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz" + integrity sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag== + +"@tsconfig/node14@^1.0.0": + version "1.0.3" + resolved "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz" + integrity sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow== + +"@tsconfig/node16@^1.0.2": + version "1.0.3" + resolved "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.3.tgz" + integrity sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ== + +"@types/bn.js@5.1.1", "@types/bn.js@^5.1.0": + version "5.1.1" + resolved "https://registry.yarnpkg.com/@types/bn.js/-/bn.js-5.1.1.tgz#b51e1b55920a4ca26e9285ff79936bbdec910682" + integrity sha512-qNrYbZqMx0uJAfKnKclPh+dTwK33KfLHYqtyODwd5HnXOjnkhc4qgn3BrK6RWyGZm5+sIFE7Q7Vz6QQtJB7w7g== + dependencies: + "@types/node" "*" + +"@types/bn.js@^4.11.3": + version "4.11.6" + resolved "https://registry.yarnpkg.com/@types/bn.js/-/bn.js-4.11.6.tgz#c306c70d9358aaea33cd4eda092a742b9505967c" + integrity sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg== + dependencies: + "@types/node" "*" + +"@types/chai@^4.3.4": + version "4.3.4" + resolved "https://registry.npmjs.org/@types/chai/-/chai-4.3.4.tgz" + integrity sha512-KnRanxnpfpjUTqTCXslZSEdLfXExwgNxYPdiO2WGUj8+HDjFi8R3k5RVKPeSCzLjCcshCAtVO2QBbVuAV4kTnw== + +"@types/connect@^3.4.33": + version "3.4.35" + resolved "https://registry.npmjs.org/@types/connect/-/connect-3.4.35.tgz" + integrity sha512-cdeYyv4KWoEgpBISTxWvqYsVy444DOqehiF3fM3ne10AmJ62RSyNkUnxMJXHQWRQQX2eR94m5y1IZyDwBjV9FQ== + dependencies: + "@types/node" "*" + +"@types/json5@^0.0.29": + version "0.0.29" + resolved "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz" + integrity sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ== + +"@types/lodash.values@^4.3.6": + version "4.3.7" + resolved "https://registry.yarnpkg.com/@types/lodash.values/-/lodash.values-4.3.7.tgz#9da9c6cf5941ff8b8f98bde9cb9f2cf7fd64eceb" + integrity sha512-Moex9/sWxtKEa+BKiH5zvmhfcieDlcz4wRxMhO/oJ2qOKUdujoU6dQjUTxWA8jwEREpHXmiY4HCwNRpycW8JQA== + dependencies: + "@types/lodash" "*" + +"@types/lodash@*": + version "4.14.194" + resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.14.194.tgz#b71eb6f7a0ff11bff59fc987134a093029258a76" + integrity sha512-r22s9tAS7imvBt2lyHC9B8AGwWnXaYb1tY09oyLkXDs4vArpYJzw09nj8MLx5VfciBPGIb+ZwG0ssYnEPJxn/g== + +"@types/long@^4.0.1", "@types/long@^4.0.2": + version "4.0.2" + resolved "https://registry.yarnpkg.com/@types/long/-/long-4.0.2.tgz#b74129719fc8d11c01868010082d483b7545591a" + integrity sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA== + +"@types/mocha@^10.0.1": + version "10.0.1" + resolved "https://registry.npmjs.org/@types/mocha/-/mocha-10.0.1.tgz" + integrity sha512-/fvYntiO1GeICvqbQ3doGDIP97vWmvFt83GKguJ6prmQM2iXZfFcq6YE8KteFyRtX2/h5Hf91BYvPodJKFYv5Q== + +"@types/node@*", "@types/node@^18.11.18": + version "18.11.18" + resolved "https://registry.npmjs.org/@types/node/-/node-18.11.18.tgz" + integrity sha512-DHQpWGjyQKSHj3ebjFI/wRKcqQcdR+MoFBygntYOZytCqNfkd2ZC4ARDJ2DQqhjH5p85Nnd3jhUJIXrszFX/JA== + +"@types/node@10.12.18": + version "10.12.18" + resolved "https://registry.yarnpkg.com/@types/node/-/node-10.12.18.tgz#1d3ca764718915584fcd9f6344621b7672665c67" + integrity sha512-fh+pAqt4xRzPfqA6eh3Z2y6fyZavRIumvjhaCL753+TVkGKGhpPeyrJG2JftD0T9q4GF00KjefsQ+PQNDdWQaQ== + +"@types/node@>=13.7.0": + version "20.1.0" + resolved "https://registry.yarnpkg.com/@types/node/-/node-20.1.0.tgz#258805edc37c327cf706e64c6957f241ca4c4c20" + integrity sha512-O+z53uwx64xY7D6roOi4+jApDGFg0qn6WHcxe5QeqjMaTezBO/mxdfFXIVAVVyNWKx84OmPB3L8kbVYOTeN34A== + +"@types/node@^12.12.54": + version "12.20.55" + resolved "https://registry.npmjs.org/@types/node/-/node-12.20.55.tgz" + integrity sha512-J8xLz7q2OFulZ2cyGTLE1TbbZcjpno7FaN6zdJNrgAdrJ+DZzh/uFR6YrTb4C+nXakvud8Q4+rbhoIWlYQbUFQ== + +"@types/node@^18.0.3": + version "18.16.5" + resolved "https://registry.yarnpkg.com/@types/node/-/node-18.16.5.tgz#bf64e42719dc2e74da24709a2e1c0b50a966120a" + integrity sha512-seOA34WMo9KB+UA78qaJoCO20RJzZGVXQ5Sh6FWu0g/hfT44nKXnej3/tCQl7FL97idFpBhisLYCTB50S0EirA== + +"@types/pbkdf2@^3.0.0": + version "3.1.0" + resolved "https://registry.yarnpkg.com/@types/pbkdf2/-/pbkdf2-3.1.0.tgz#039a0e9b67da0cdc4ee5dab865caa6b267bb66b1" + integrity sha512-Cf63Rv7jCQ0LaL8tNXmEyqTHuIJxRdlS5vMh1mj5voN4+QFhVZnlZruezqpWYDiJ8UTzhP0VmeLXCmBk66YrMQ== + dependencies: + "@types/node" "*" + +"@types/secp256k1@^4.0.1": + version "4.0.3" + resolved "https://registry.yarnpkg.com/@types/secp256k1/-/secp256k1-4.0.3.tgz#1b8e55d8e00f08ee7220b4d59a6abe89c37a901c" + integrity sha512-Da66lEIFeIz9ltsdMZcpQvmrmmoqrfju8pm1BH8WbYjZSwUgCwXLb9C+9XYogwBITnbsSaMdVPb2ekf7TV+03w== + dependencies: + "@types/node" "*" + +"@types/ws@^7.4.4": + version "7.4.7" + resolved "https://registry.npmjs.org/@types/ws/-/ws-7.4.7.tgz" + integrity sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww== + dependencies: + "@types/node" "*" + +"@types/yargs-parser@*": + version "21.0.0" + resolved "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.0.tgz" + integrity sha512-iO9ZQHkZxHn4mSakYV0vFHAVDyEOIJQrV2uZ06HxEPcx+mt8swXoZHIbaaJ2crJYFfErySgktuTZ3BeLz+XmFA== + +"@types/yargs@^17.0.20": + version "17.0.20" + resolved "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.20.tgz" + integrity sha512-eknWrTHofQuPk2iuqDm1waA7V6xPlbgBoaaXEgYkClhLOnB0TtbW+srJaOToAgawPxPlHQzwypFA2bhZaUGP5A== + dependencies: + "@types/yargs-parser" "*" + +"@wry/context@^0.7.0": + version "0.7.2" + resolved "https://registry.yarnpkg.com/@wry/context/-/context-0.7.2.tgz#732fa01cf11d08c07114ddf51d67c3757d68f31d" + integrity sha512-WBGObg2bxt9UYGX4Dh3heUpHeULiFIP/yLpKrcebPfwaLuwCSj6rS7kpQegQ/K7jbkTQ1nLGZnfyAvY1T2LG4g== + dependencies: + tslib "^2.3.0" + +"@wry/equality@^0.5.0": + version "0.5.5" + resolved "https://registry.yarnpkg.com/@wry/equality/-/equality-0.5.5.tgz#523a15f670e6d15408bf8f67259682e18a5543f0" + integrity sha512-tI95+tJlL2LoOY27EHy0V0zKRVgbPp6vk9p6ZqWZOCSVslEhYEGeI+gaskc2rnjQxfszsXhtgYZTQ1xAUrMkOg== + dependencies: + tslib "^2.3.0" + +"@wry/trie@^0.3.0": + version "0.3.2" + resolved "https://registry.yarnpkg.com/@wry/trie/-/trie-0.3.2.tgz#a06f235dc184bd26396ba456711f69f8c35097e6" + integrity sha512-yRTyhWSls2OY/pYLfwff867r8ekooZ4UI+/gxot5Wj8EFwSf2rG+n+Mo/6LoLQm1TKA4GRj2+LCpbfS937dClQ== + dependencies: + tslib "^2.3.0" + +"@xpla/xpla.js@^0.2.1": + version "0.2.3" + resolved "https://registry.yarnpkg.com/@xpla/xpla.js/-/xpla.js-0.2.3.tgz#c614d98e599fe03f9edc425f50f66481983e8dac" + integrity sha512-Tfk7hCGWXtwr08reY3Pi6dmzIqFbzri9jcyzJdfNmdo4cN0PMwpRJuZZcPmtxiIUnNef3AN1E/6nJUD5MKniuA== + dependencies: + "@ethersproject/bytes" "^5.6.1" + "@ethersproject/keccak256" "^5.6.1" + "@ethersproject/signing-key" "^5.6.2" + "@terra-money/legacy.proto" "npm:@terra-money/terra.proto@^0.1.7" + "@terra-money/terra.proto" "^2.1.0" + axios "^0.26.1" + bech32 "^2.0.0" + bip32 "^2.0.6" + bip39 "^3.0.3" + bufferutil "^4.0.3" + crypto-addr-codec "^0.1.7" + decimal.js "^10.2.1" + elliptic "^6.5.4" + ethereumjs-util "^7.1.5" + jscrypto "^1.0.1" + readable-stream "^3.6.0" + secp256k1 "^4.0.2" + tmp "^0.2.1" + utf-8-validate "^5.0.5" + ws "^7.5.8" + +JSONStream@^1.3.5: + version "1.3.5" + resolved "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz" + integrity sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ== + dependencies: + jsonparse "^1.2.0" + through ">=2.2.7 <3" + +acorn-walk@^8.1.1: + version "8.2.0" + resolved "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.2.0.tgz" + integrity sha512-k+iyHEuPgSw6SbuDpGQM+06HQUa04DZ3o+F6CSzXMvvI5KMvnaEqXe+YVe555R9nn6GPt404fos4wcgpw12SDA== + +acorn@7.1.1: + version "7.1.1" + resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.1.1.tgz#e35668de0b402f359de515c5482a1ab9f89a69bf" + integrity sha512-add7dgA5ppRPxCFJoAGfMDi7PIBXq1RtGo7BhbLaxwrXPOmw8gq48Y9ozT01hUKy9byMjlR20EJhu5zlkErEkg== + +acorn@^8.4.1: + version "8.8.1" + resolved "https://registry.npmjs.org/acorn/-/acorn-8.8.1.tgz" + integrity sha512-7zFpHzhnqYKrkYdUjF1HI1bzd0VygEGX8lFk4k5zVMqHEoES+P+7TKI+EvLO9WVMJ8eekdO0aDEK044xTXwPPA== + +aes-js@3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/aes-js/-/aes-js-3.0.0.tgz" + integrity sha512-H7wUZRn8WpTq9jocdxQ2c8x2sKo9ZVmzfRE13GiNJXfp7NcKYEdvl3vspKjXox6RIG2VtaRe4JFvxG4rqp2Zuw== + +agentkeepalive@^4.2.1: + version "4.3.0" + resolved "https://registry.yarnpkg.com/agentkeepalive/-/agentkeepalive-4.3.0.tgz#bb999ff07412653c1803b3ced35e50729830a255" + integrity sha512-7Epl1Blf4Sy37j4v9f9FjICCh4+KAQOyXgHEwlyBiAQLbhKdq/i2QQU3amQalS/wPhdPzDXPL5DMR5bkn+YeWg== + dependencies: + debug "^4.1.0" + depd "^2.0.0" + humanize-ms "^1.2.1" + +algo-msgpack-with-bigint@^2.1.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/algo-msgpack-with-bigint/-/algo-msgpack-with-bigint-2.1.1.tgz#38bb717220525b3ff42232eefdcd9efb9ad405d6" + integrity sha512-F1tGh056XczEaEAqu7s+hlZUDWwOBT70Eq0lfMpBP2YguSQVyxRbprLq5rELXKQOyOaixTWYhMeMQMzP0U5FoQ== + +algosdk@^1.15.0: + version "1.24.1" + resolved "https://registry.yarnpkg.com/algosdk/-/algosdk-1.24.1.tgz#afc4102457ae0c38a32de6b84f4d713aedfc9e89" + integrity sha512-9moZxdqeJ6GdE4N6fA/GlUP4LrbLZMYcYkt141J4Ss68OfEgH9qW0wBuZ3ZOKEx/xjc5bg7mLP2Gjg7nwrkmww== + dependencies: + algo-msgpack-with-bigint "^2.1.1" + buffer "^6.0.2" + cross-fetch "^3.1.5" + hi-base32 "^0.5.1" + js-sha256 "^0.9.0" + js-sha3 "^0.8.0" + js-sha512 "^0.8.0" + json-bigint "^1.0.0" + tweetnacl "^1.0.3" + vlq "^2.0.4" + +ansi-colors@4.1.1: + version "4.1.1" + resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz" + integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA== + +ansi-regex@^5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz" + integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== + +ansi-styles@^3.2.1: + version "3.2.1" + resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d" + integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA== + dependencies: + color-convert "^1.9.0" + +ansi-styles@^4.0.0, ansi-styles@^4.1.0: + version "4.3.0" + resolved "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz" + integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== + dependencies: + color-convert "^2.0.1" + +anymatch@~3.1.2: + version "3.1.3" + resolved "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz" + integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw== + dependencies: + normalize-path "^3.0.0" + picomatch "^2.0.4" + +aptos@1.5.0: + version "1.5.0" + resolved "https://registry.yarnpkg.com/aptos/-/aptos-1.5.0.tgz#43263b13c878d2497d875d50aaee10355932c2e6" + integrity sha512-N7OuRtU7IYHkDkNx+4QS3g/QQGCp+36KzYn3oXPmT7Kttfuv+UKliQVdjy3cLmwd/DCQSh9ObTovwdxnHjUn0g== + dependencies: + "@noble/hashes" "1.1.3" + "@scure/bip39" "1.1.0" + axios "0.27.2" + form-data "4.0.0" + tweetnacl "1.0.3" + +arg@^4.1.0: + version "4.1.3" + resolved "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz" + integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA== + +argparse@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz" + integrity sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q== + +arrify@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz" + integrity sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA== + +assertion-error@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz" + integrity sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw== + +asynckit@^0.4.0: + version "0.4.0" + resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79" + integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q== + +axios@0.27.2, axios@^0.27.2: + version "0.27.2" + resolved "https://registry.yarnpkg.com/axios/-/axios-0.27.2.tgz#207658cc8621606e586c85db4b41a750e756d972" + integrity sha512-t+yRIyySRTp/wua5xEr+z1q60QmLq8ABsS5O9Me1AsE5dfKqgnCFzwiCZZ/cGNd1lq4/7akDWMxdhVlucjmnOQ== + dependencies: + follow-redirects "^1.14.9" + form-data "^4.0.0" + +axios@^0.21.1, axios@^0.21.2: + version "0.21.4" + resolved "https://registry.yarnpkg.com/axios/-/axios-0.21.4.tgz#c67b90dc0568e5c1cf2b0b858c43ba28e2eda575" + integrity sha512-ut5vewkiu8jjGBdqpM44XxjuCjq9LAKeHVmoVfHVzy8eHgxxq8SbAVQNovDA8mVi05kP0Ea/n/UzcSHcTJQfNg== + dependencies: + follow-redirects "^1.14.0" + +axios@^0.24.0: + version "0.24.0" + resolved "https://registry.yarnpkg.com/axios/-/axios-0.24.0.tgz#804e6fa1e4b9c5288501dd9dff56a7a0940d20d6" + integrity sha512-Q6cWsys88HoPgAaFAVUb0WpPk0O8iTeisR9IMqy9G8AbO4NlpVknrnQS03zzF9PGAWgO3cgletO3VjV/P7VztA== + dependencies: + follow-redirects "^1.14.4" + +axios@^0.26.1: + version "0.26.1" + resolved "https://registry.yarnpkg.com/axios/-/axios-0.26.1.tgz#1ede41c51fcf51bbbd6fd43669caaa4f0495aaa9" + integrity sha512-fPwcX4EvnSHuInCMItEhAGnaSEXRBjtzh9fOtsE6E1G6p7vl7edEeZe11QHf18+6+9gR5PbKV/sGKNaD8YaMeA== + dependencies: + follow-redirects "^1.14.8" + +balanced-match@^1.0.0: + version "1.0.2" + resolved "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz" + integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== + +base-x@^3.0.2, base-x@^3.0.8: + version "3.0.9" + resolved "https://registry.yarnpkg.com/base-x/-/base-x-3.0.9.tgz#6349aaabb58526332de9f60995e548a53fe21320" + integrity sha512-H7JU6iBHTal1gp56aKoaa//YUxEaAOUiydvrV/pILqIHXTtqxSkATOnDA2u+jZ/61sD+L/412+7kzXRtWukhpQ== + dependencies: + safe-buffer "^5.0.1" + +base-x@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/base-x/-/base-x-4.0.0.tgz" + integrity sha512-FuwxlW4H5kh37X/oW59pwTzzTKRzfrrQwhmyspRM7swOEZcHtDZSCt45U6oKgtuFE+WYPblePMVIPR4RZrh/hw== + +base64-js@^1.3.0, base64-js@^1.3.1, base64-js@^1.5.1: + version "1.5.1" + resolved "https://registry.yarnpkg.com/base64-js/-/base64-js-1.5.1.tgz#1b1b440160a5bf7ad40b650f095963481903930a" + integrity sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA== + +bech32@1.1.4, bech32@^1.1.4: + version "1.1.4" + resolved "https://registry.npmjs.org/bech32/-/bech32-1.1.4.tgz" + integrity sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ== + +bech32@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/bech32/-/bech32-2.0.0.tgz#078d3686535075c8c79709f054b1b226a133b355" + integrity sha512-LcknSilhIGatDAsY1ak2I8VtGaHNhgMSYVxFrGLXv+xLHytaKZKcaUJJUE7qmBr7h33o5YQwP55pMI0xmkpJwg== + +big-integer@1.6.36: + version "1.6.36" + resolved "https://registry.yarnpkg.com/big-integer/-/big-integer-1.6.36.tgz#78631076265d4ae3555c04f85e7d9d2f3a071a36" + integrity sha512-t70bfa7HYEA1D9idDbmuv7YbsbVkQ+Hp+8KFSul4aE5e/i1bjCNIRYJZlA8Q8p0r9T8cF/RVvwUgRA//FydEyg== + +bigint-buffer@^1.1.5: + version "1.1.5" + resolved "https://registry.yarnpkg.com/bigint-buffer/-/bigint-buffer-1.1.5.tgz#d038f31c8e4534c1f8d0015209bf34b4fa6dd442" + integrity sha512-trfYco6AoZ+rKhKnxA0hgX0HAbVP/s808/EuDSe2JDzUnCp/xAsli35Orvk67UrTEcwuxZqYZDmfA2RXJgxVvA== + dependencies: + bindings "^1.3.0" + +bignumber.js@^9.0.0, bignumber.js@^9.0.1: + version "9.1.1" + resolved "https://registry.yarnpkg.com/bignumber.js/-/bignumber.js-9.1.1.tgz#c4df7dc496bd849d4c9464344c1aa74228b4dac6" + integrity sha512-pHm4LsMJ6lzgNGVfZHjMoO8sdoRhOzOH4MLmY65Jg70bpxCKu5iOHNJyfF6OyvYw7t8Fpf35RuzUyqnQsj8Vig== + +binary-extensions@^2.0.0: + version "2.2.0" + resolved "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz" + integrity sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA== + +binary-parser@^2.2.1: + version "2.2.1" + resolved "https://registry.yarnpkg.com/binary-parser/-/binary-parser-2.2.1.tgz#4edc6da2dc56db73fa5ba450dfe6382ede8294ce" + integrity sha512-5ATpz/uPDgq5GgEDxTB4ouXCde7q2lqAQlSdBRQVl/AJnxmQmhIfyxJx+0MGu//D5rHQifkfGbWWlaysG0o9NA== + +bindings@^1.3.0, bindings@^1.5.0: + version "1.5.0" + resolved "https://registry.yarnpkg.com/bindings/-/bindings-1.5.0.tgz#10353c9e945334bc0511a6d90b38fbc7c9c504df" + integrity sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ== + dependencies: + file-uri-to-path "1.0.0" + +bip32@^2.0.6: + version "2.0.6" + resolved "https://registry.yarnpkg.com/bip32/-/bip32-2.0.6.tgz#6a81d9f98c4cd57d05150c60d8f9e75121635134" + integrity sha512-HpV5OMLLGTjSVblmrtYRfFFKuQB+GArM0+XP8HGWfJ5vxYBqo+DesvJwOdC2WJ3bCkZShGf0QIfoIpeomVzVdA== + dependencies: + "@types/node" "10.12.18" + bs58check "^2.1.1" + create-hash "^1.2.0" + create-hmac "^1.1.7" + tiny-secp256k1 "^1.1.3" + typeforce "^1.11.5" + wif "^2.0.6" + +bip39@^3.0.3, bip39@^3.0.4: + version "3.1.0" + resolved "https://registry.yarnpkg.com/bip39/-/bip39-3.1.0.tgz#c55a418deaf48826a6ceb34ac55b3ee1577e18a3" + integrity sha512-c9kiwdk45Do5GL0vJMe7tS95VjCii65mYAH7DfWl3uW8AVzXKQVUm64i3hzVybBDMp9r7j9iNxR85+ul8MdN/A== + dependencies: + "@noble/hashes" "^1.2.0" + +bip66@^1.1.5: + version "1.1.5" + resolved "https://registry.yarnpkg.com/bip66/-/bip66-1.1.5.tgz#01fa8748785ca70955d5011217d1b3139969ca22" + integrity sha512-nemMHz95EmS38a26XbbdxIYj5csHd3RMP3H5bwQknX0WYHF01qhpufP42mLOwVICuH2JmhIhXiWs89MfUGL7Xw== + dependencies: + safe-buffer "^5.0.1" + +blakejs@^1.1.0: + version "1.2.1" + resolved "https://registry.yarnpkg.com/blakejs/-/blakejs-1.2.1.tgz#5057e4206eadb4a97f7c0b6e197a505042fc3814" + integrity sha512-QXUSXI3QVc/gJME0dBpXrag1kbzOqCjCX8/b54ntNyW6sjtoqxqRk3LTmXzaJoh71zMsDCjM+47jS7XiwN/+fQ== + +bn.js@5.2.1, bn.js@^5.0.0, bn.js@^5.1.2, bn.js@^5.2.0, bn.js@^5.2.1: + version "5.2.1" + resolved "https://registry.npmjs.org/bn.js/-/bn.js-5.2.1.tgz" + integrity sha512-eXRvHzWyYPBuB4NBy0cmYQjGitUrtqwbvlzP3G6VFnNRbsZQIxQ10PbKKHt8gZ/HW/D/747aDl+QkDqg3KQLMQ== + +bn.js@^4.11.0, bn.js@^4.11.8, bn.js@^4.11.9: + version "4.12.0" + resolved "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz" + integrity sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA== + +borsh@^0.7.0: + version "0.7.0" + resolved "https://registry.yarnpkg.com/borsh/-/borsh-0.7.0.tgz#6e9560d719d86d90dc589bca60ffc8a6c51fec2a" + integrity sha512-CLCsZGIBCFnPtkNnieW/a8wmreDmfUtjU2m9yHrzPXIlNbqVs0AQrSatSG6vdNYUqdc83tkQi2eHfF98ubzQLA== + dependencies: + bn.js "^5.2.0" + bs58 "^4.0.0" + text-encoding-utf-8 "^1.0.2" + +brace-expansion@^1.1.7: + version "1.1.11" + resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz" + integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA== + dependencies: + balanced-match "^1.0.0" + concat-map "0.0.1" + +brace-expansion@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz" + integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA== + dependencies: + balanced-match "^1.0.0" + +braces@~3.0.2: + version "3.0.2" + resolved "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz" + integrity sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A== + dependencies: + fill-range "^7.0.1" + +brorand@^1.1.0: + version "1.1.0" + resolved "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz" + integrity sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w== + +browser-headers@^0.4.1: + version "0.4.1" + resolved "https://registry.yarnpkg.com/browser-headers/-/browser-headers-0.4.1.tgz#4308a7ad3b240f4203dbb45acedb38dc2d65dd02" + integrity sha512-CA9hsySZVo9371qEHjHZtYxV2cFtVj5Wj/ZHi8ooEsrtm4vOnl9Y9HmyYWk9q+05d7K3rdoAE0j3MVEFVvtQtg== + +browser-stdout@1.3.1: + version "1.3.1" + resolved "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.1.tgz" + integrity sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw== + +browserify-aes@^1.0.6, browserify-aes@^1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/browserify-aes/-/browserify-aes-1.2.0.tgz#326734642f403dabc3003209853bb70ad428ef48" + integrity sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA== + dependencies: + buffer-xor "^1.0.3" + cipher-base "^1.0.0" + create-hash "^1.1.0" + evp_bytestokey "^1.0.3" + inherits "^2.0.1" + safe-buffer "^5.0.1" + +bs58@^4.0.0, bs58@^4.0.1: + version "4.0.1" + resolved "https://registry.yarnpkg.com/bs58/-/bs58-4.0.1.tgz#be161e76c354f6f788ae4071f63f34e8c4f0a42a" + integrity sha512-Ok3Wdf5vOIlBrgCvTq96gBkJw+JUEzdBgyaza5HLtPm7yTHkjRy8+JzNyHF7BHa0bNWOQIp3m5YF0nnFcOIKLw== + dependencies: + base-x "^3.0.2" + +bs58@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/bs58/-/bs58-5.0.0.tgz" + integrity sha512-r+ihvQJvahgYT50JD05dyJNKlmmSlMoOGwn1lCcEzanPglg7TxYjioQUYehQ9mAR/+hOSd2jRc/Z2y5UxBymvQ== + dependencies: + base-x "^4.0.0" + +bs58check@<3.0.0, bs58check@^2.1.1, bs58check@^2.1.2: + version "2.1.2" + resolved "https://registry.yarnpkg.com/bs58check/-/bs58check-2.1.2.tgz#53b018291228d82a5aa08e7d796fdafda54aebfc" + integrity sha512-0TS1jicxdU09dwJMNZtVAfzPi6Q6QeN0pM1Fkzrjn+XYHvzMKPU3pHVpva+769iNVSfIYWf7LJ6WR+BuuMf8cA== + dependencies: + bs58 "^4.0.0" + create-hash "^1.1.0" + safe-buffer "^5.1.2" + +buffer-from@^1.0.0, buffer-from@^1.1.0: + version "1.1.2" + resolved "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz" + integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ== + +buffer-layout@^1.2.0, buffer-layout@^1.2.2: + version "1.2.2" + resolved "https://registry.yarnpkg.com/buffer-layout/-/buffer-layout-1.2.2.tgz#b9814e7c7235783085f9ca4966a0cfff112259d5" + integrity sha512-kWSuLN694+KTk8SrYvCqwP2WcgQjoRCiF5b4QDvkkz8EmgD+aWAIceGFKMIAdmF/pH+vpgNV3d3kAKorcdAmWA== + +buffer-xor@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/buffer-xor/-/buffer-xor-1.0.3.tgz#26e61ed1422fb70dd42e6e36729ed51d855fe8d9" + integrity sha512-571s0T7nZWK6vB67HI5dyUF7wXiNcfaPPPTl6zYCNApANjIvYJTg7hlud/+cJpdAhS7dVzqMLmfhfHR3rAcOjQ== + +buffer@6.0.3, buffer@^6.0.2, buffer@^6.0.3, buffer@~6.0.3: + version "6.0.3" + resolved "https://registry.yarnpkg.com/buffer/-/buffer-6.0.3.tgz#2ace578459cc8fbe2a70aaa8f52ee63b6a74c6c6" + integrity sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA== + dependencies: + base64-js "^1.3.1" + ieee754 "^1.2.1" + +bufferutil@^4.0.1, bufferutil@^4.0.3: + version "4.0.7" + resolved "https://registry.npmjs.org/bufferutil/-/bufferutil-4.0.7.tgz" + integrity sha512-kukuqc39WOHtdxtw4UScxF/WVnMFVSQVKhtx3AjZJzhd0RGZZldcrfSEbVsWWe6KNH253574cq5F+wpv0G9pJw== + dependencies: + node-gyp-build "^4.3.0" + +camelcase@^5.3.1: + version "5.3.1" + resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320" + integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg== + +camelcase@^6.0.0: + version "6.3.0" + resolved "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz" + integrity sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA== + +capability@^0.2.5: + version "0.2.5" + resolved "https://registry.yarnpkg.com/capability/-/capability-0.2.5.tgz#51ad87353f1936ffd77f2f21c74633a4dea88801" + integrity sha512-rsJZYVCgXd08sPqwmaIqjAd5SUTfonV0z/gDJ8D6cN8wQphky1kkAYEqQ+hmDxTw7UihvBfjUVUSY+DBEe44jg== + +chai@^4.3.7: + version "4.3.7" + resolved "https://registry.npmjs.org/chai/-/chai-4.3.7.tgz" + integrity sha512-HLnAzZ2iupm25PlN0xFreAlBA5zaBSv3og0DdeGA4Ar6h6rJ3A0rolRUKJhSF2V10GZKDgWF/VmAEsNWjCRB+A== + dependencies: + assertion-error "^1.1.0" + check-error "^1.0.2" + deep-eql "^4.1.2" + get-func-name "^2.0.0" + loupe "^2.3.1" + pathval "^1.1.1" + type-detect "^4.0.5" + +chalk@^2.4.1: + version "2.4.2" + resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424" + integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ== + dependencies: + ansi-styles "^3.2.1" + escape-string-regexp "^1.0.5" + supports-color "^5.3.0" + +chalk@^4.1.0: + version "4.1.2" + resolved "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz" + integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA== + dependencies: + ansi-styles "^4.1.0" + supports-color "^7.1.0" + +check-error@^1.0.2: + version "1.0.2" + resolved "https://registry.npmjs.org/check-error/-/check-error-1.0.2.tgz" + integrity sha512-BrgHpW9NURQgzoNyjfq0Wu6VFO6D7IZEmJNdtgNqpzGG8RuNFHt2jQxWlAs4HMe119chBnv+34syEZtc6IhLtA== + +chokidar@3.5.3: + version "3.5.3" + resolved "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz" + integrity sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw== + dependencies: + anymatch "~3.1.2" + braces "~3.0.2" + glob-parent "~5.1.2" + is-binary-path "~2.1.0" + is-glob "~4.0.1" + normalize-path "~3.0.0" + readdirp "~3.6.0" + optionalDependencies: + fsevents "~2.3.2" + +cipher-base@^1.0.0, cipher-base@^1.0.1, cipher-base@^1.0.3: + version "1.0.4" + resolved "https://registry.yarnpkg.com/cipher-base/-/cipher-base-1.0.4.tgz#8760e4ecc272f4c363532f926d874aae2c1397de" + integrity sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q== + dependencies: + inherits "^2.0.1" + safe-buffer "^5.0.1" + +cliui@^7.0.2: + version "7.0.4" + resolved "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz" + integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ== + dependencies: + string-width "^4.2.0" + strip-ansi "^6.0.0" + wrap-ansi "^7.0.0" + +cliui@^8.0.1: + version "8.0.1" + resolved "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz" + integrity sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ== + dependencies: + string-width "^4.2.0" + strip-ansi "^6.0.1" + wrap-ansi "^7.0.0" + +color-convert@^1.9.0: + version "1.9.3" + resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8" + integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg== + dependencies: + color-name "1.1.3" + +color-convert@^2.0.1: + version "2.0.1" + resolved "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz" + integrity sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ== + dependencies: + color-name "~1.1.4" + +color-name@1.1.3: + version "1.1.3" + resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25" + integrity sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw== + +color-name@~1.1.4: + version "1.1.4" + resolved "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz" + integrity sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA== + +combined-stream@^1.0.8: + version "1.0.8" + resolved "https://registry.yarnpkg.com/combined-stream/-/combined-stream-1.0.8.tgz#c3d45a8b34fd730631a110a8a2520682b31d5a7f" + integrity sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg== + dependencies: + delayed-stream "~1.0.0" + +commander@^2.20.3: + version "2.20.3" + resolved "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz" + integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ== + +concat-map@0.0.1: + version "0.0.1" + resolved "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz" + integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg== + +copyfiles@^2.4.1: + version "2.4.1" + resolved "https://registry.yarnpkg.com/copyfiles/-/copyfiles-2.4.1.tgz#d2dcff60aaad1015f09d0b66e7f0f1c5cd3c5da5" + integrity sha512-fereAvAvxDrQDOXybk3Qu3dPbOoKoysFMWtkY3mv5BsL8//OSZVL5DCLYqgRfY5cWirgRzlC+WSrxp6Bo3eNZg== + dependencies: + glob "^7.0.5" + minimatch "^3.0.3" + mkdirp "^1.0.4" + noms "0.0.0" + through2 "^2.0.1" + untildify "^4.0.0" + yargs "^16.1.0" + +core-util-is@~1.0.0: + version "1.0.3" + resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.3.tgz#a6042d3634c2b27e9328f837b965fac83808db85" + integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ== + +cosmjs-types@^0.7.1: + version "0.7.2" + resolved "https://registry.yarnpkg.com/cosmjs-types/-/cosmjs-types-0.7.2.tgz#a757371abd340949c5bd5d49c6f8379ae1ffd7e2" + integrity sha512-vf2uLyktjr/XVAgEq0DjMxeAWh1yYREe7AMHDKd7EiHVqxBPCaBS+qEEQUkXbR9ndnckqr1sUG8BQhazh4X5lA== + dependencies: + long "^4.0.0" + protobufjs "~6.11.2" + +crc-32@^1.2.0: + version "1.2.2" + resolved "https://registry.yarnpkg.com/crc-32/-/crc-32-1.2.2.tgz#3cad35a934b8bf71f25ca524b6da51fb7eace2ff" + integrity sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ== + +create-hash@^1.1.0, create-hash@^1.1.2, create-hash@^1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/create-hash/-/create-hash-1.2.0.tgz#889078af11a63756bcfb59bd221996be3a9ef196" + integrity sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg== + dependencies: + cipher-base "^1.0.1" + inherits "^2.0.1" + md5.js "^1.3.4" + ripemd160 "^2.0.1" + sha.js "^2.4.0" + +create-hmac@^1.1.4, create-hmac@^1.1.7: + version "1.1.7" + resolved "https://registry.yarnpkg.com/create-hmac/-/create-hmac-1.1.7.tgz#69170c78b3ab957147b2b8b04572e47ead2243ff" + integrity sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg== + dependencies: + cipher-base "^1.0.3" + create-hash "^1.1.0" + inherits "^2.0.1" + ripemd160 "^2.0.0" + safe-buffer "^5.0.1" + sha.js "^2.4.8" + +create-require@^1.1.0: + version "1.1.1" + resolved "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz" + integrity sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ== + +cross-fetch@^3.1.5: + version "3.1.5" + resolved "https://registry.yarnpkg.com/cross-fetch/-/cross-fetch-3.1.5.tgz#e1389f44d9e7ba767907f7af8454787952ab534f" + integrity sha512-lvb1SBsI0Z7GDwmuid+mU3kWVBwTVUbe7S0H52yaaAdQOXq2YktTCZdlAcNKFzE6QtRz0snpw9bNiPeOIkkQvw== + dependencies: + node-fetch "2.6.7" + +crypto-addr-codec@^0.1.7: + version "0.1.7" + resolved "https://registry.yarnpkg.com/crypto-addr-codec/-/crypto-addr-codec-0.1.7.tgz#e16cea892730178fe25a38f6d15b680cab3124ae" + integrity sha512-X4hzfBzNhy4mAc3UpiXEC/L0jo5E8wAa9unsnA8nNXYzXjCcGk83hfC5avJWCSGT8V91xMnAS9AKMHmjw5+XCg== + dependencies: + base-x "^3.0.8" + big-integer "1.6.36" + blakejs "^1.1.0" + bs58 "^4.0.1" + ripemd160-min "0.0.6" + safe-buffer "^5.2.0" + sha3 "^2.1.1" + +crypto-hash@^1.3.0: + version "1.3.0" + resolved "https://registry.yarnpkg.com/crypto-hash/-/crypto-hash-1.3.0.tgz#b402cb08f4529e9f4f09346c3e275942f845e247" + integrity sha512-lyAZ0EMyjDkVvz8WOeVnuCPvKVBXcMv1l5SVqO1yC7PzTwrD/pPje/BIRbWhMoPe436U+Y2nD7f5bFx0kt+Sbg== + +debug@4.3.4, debug@^4.1.0: + version "4.3.4" + resolved "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz" + integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ== + dependencies: + ms "2.1.2" + +decamelize@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/decamelize/-/decamelize-4.0.0.tgz" + integrity sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ== + +decimal.js@^10.2.1: + version "10.4.3" + resolved "https://registry.yarnpkg.com/decimal.js/-/decimal.js-10.4.3.tgz#1044092884d245d1b7f65725fa4ad4c6f781cc23" + integrity sha512-VBBaLc1MgL5XpzgIP7ny5Z6Nx3UrRkIViUkPUdtl9aya5amy3De1gsUUSB1g3+3sExYNjCAsAznmukyxCb1GRA== + +deep-eql@^4.1.2: + version "4.1.3" + resolved "https://registry.npmjs.org/deep-eql/-/deep-eql-4.1.3.tgz" + integrity sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw== + dependencies: + type-detect "^4.0.0" + +define-properties@^1.1.3: + version "1.2.0" + resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.2.0.tgz#52988570670c9eacedd8064f4a990f2405849bd5" + integrity sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA== + dependencies: + has-property-descriptors "^1.0.0" + object-keys "^1.1.1" + +delay@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/delay/-/delay-5.0.0.tgz" + integrity sha512-ReEBKkIfe4ya47wlPYf/gu5ib6yUG0/Aez0JQZQz94kiWtRQvZIQbTiehsnwHvLSWJnQdhVeqYue7Id1dKr0qw== + +delayed-stream@~1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619" + integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ== + +depd@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/depd/-/depd-2.0.0.tgz#b696163cc757560d09cf22cc8fad1571b79e76df" + integrity sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw== + +depd@~1.1.2: + version "1.1.2" + resolved "https://registry.yarnpkg.com/depd/-/depd-1.1.2.tgz#9bcd52e14c097763e749b274c4346ed2e560b5a9" + integrity sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ== + +diff@5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/diff/-/diff-5.0.0.tgz" + integrity sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w== + +diff@^3.1.0: + version "3.5.0" + resolved "https://registry.npmjs.org/diff/-/diff-3.5.0.tgz" + integrity sha512-A46qtFgd+g7pDZinpnwiRJtxbC1hpgf0uzP3iG89scHk0AUC7A1TGxf5OiiOUv/JMZR8GOt8hL900hV0bOy5xA== + +diff@^4.0.1: + version "4.0.2" + resolved "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz" + integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A== + +dot-case@^3.0.4: + version "3.0.4" + resolved "https://registry.yarnpkg.com/dot-case/-/dot-case-3.0.4.tgz#9b2b670d00a431667a8a75ba29cd1b98809ce751" + integrity sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w== + dependencies: + no-case "^3.0.4" + tslib "^2.0.3" + +drbg.js@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/drbg.js/-/drbg.js-1.0.1.tgz#3e36b6c42b37043823cdbc332d58f31e2445480b" + integrity sha512-F4wZ06PvqxYLFEZKkFxTDcns9oFNk34hvmJSEwdzsxVQ8YI5YaxtACgQatkYgv2VI2CFkUd2Y+xosPQnHv809g== + dependencies: + browserify-aes "^1.0.6" + create-hash "^1.1.2" + create-hmac "^1.1.4" + +eccrypto@1.1.6: + version "1.1.6" + resolved "https://registry.yarnpkg.com/eccrypto/-/eccrypto-1.1.6.tgz#846bd1222323036f7a3515613704386399702bd3" + integrity sha512-d78ivVEzu7Tn0ZphUUaL43+jVPKTMPFGtmgtz1D0LrFn7cY3K8CdrvibuLz2AAkHBLKZtR8DMbB2ukRYFk987A== + dependencies: + acorn "7.1.1" + elliptic "6.5.4" + es6-promise "4.2.8" + nan "2.14.0" + optionalDependencies: + secp256k1 "3.7.1" + +elliptic@6.5.4, elliptic@^6.4.0, elliptic@^6.4.1, elliptic@^6.5.2, elliptic@^6.5.4: + version "6.5.4" + resolved "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz" + integrity sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ== + dependencies: + bn.js "^4.11.9" + brorand "^1.1.0" + hash.js "^1.0.0" + hmac-drbg "^1.0.1" + inherits "^2.0.4" + minimalistic-assert "^1.0.1" + minimalistic-crypto-utils "^1.0.1" + +emoji-regex@^8.0.0: + version "8.0.0" + resolved "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz" + integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== + +error-polyfill@^0.1.3: + version "0.1.3" + resolved "https://registry.yarnpkg.com/error-polyfill/-/error-polyfill-0.1.3.tgz#df848b61ad8834f7a5db69a70b9913df86721d15" + integrity sha512-XHJk60ufE+TG/ydwp4lilOog549iiQF2OAPhkk9DdiYWMrltz5yhDz/xnKuenNwP7gy3dsibssO5QpVhkrSzzg== + dependencies: + capability "^0.2.5" + o3 "^1.0.3" + u3 "^0.1.1" + +es6-promise@4.2.8, es6-promise@^4.0.3: + version "4.2.8" + resolved "https://registry.npmjs.org/es6-promise/-/es6-promise-4.2.8.tgz" + integrity sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w== + +es6-promisify@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/es6-promisify/-/es6-promisify-5.0.0.tgz" + integrity sha512-C+d6UdsYDk0lMebHNR4S2NybQMMngAOnOwYBQjTOiv0MkoJMP0Myw2mgpDLBcpfCmRLxyFqYhS/CfOENq4SJhQ== + dependencies: + es6-promise "^4.0.3" + +escalade@^3.1.1: + version "3.1.1" + resolved "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz" + integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw== + +escape-string-regexp@4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz" + integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA== + +escape-string-regexp@^1.0.5: + version "1.0.5" + resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4" + integrity sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg== + +eth-crypto@^2.6.0: + version "2.6.0" + resolved "https://registry.yarnpkg.com/eth-crypto/-/eth-crypto-2.6.0.tgz#b777f367ae8c70e5917b3b7d52adab6b34841e29" + integrity sha512-GCX4ffFYRUGgnuWR5qxcZIRQJ1KEqPFiyXU9yVy7s6dtXIMlUXZQ2h+5ID6rFaOHWbpJbjfkC6YdhwtwRYCnug== + dependencies: + "@babel/runtime" "7.20.13" + "@ethereumjs/tx" "3.5.2" + "@types/bn.js" "5.1.1" + eccrypto "1.1.6" + ethereumjs-util "7.1.5" + ethers "5.7.2" + secp256k1 "5.0.0" + +ethereum-cryptography@^0.1.3: + version "0.1.3" + resolved "https://registry.yarnpkg.com/ethereum-cryptography/-/ethereum-cryptography-0.1.3.tgz#8d6143cfc3d74bf79bbd8edecdf29e4ae20dd191" + integrity sha512-w8/4x1SGGzc+tO97TASLja6SLd3fRIK2tLVcV2Gx4IB21hE19atll5Cq9o3d0ZmAYC/8aw0ipieTSiekAea4SQ== + dependencies: + "@types/pbkdf2" "^3.0.0" + "@types/secp256k1" "^4.0.1" + blakejs "^1.1.0" + browserify-aes "^1.2.0" + bs58check "^2.1.2" + create-hash "^1.2.0" + create-hmac "^1.1.7" + hash.js "^1.1.7" + keccak "^3.0.0" + pbkdf2 "^3.0.17" + randombytes "^2.1.0" + safe-buffer "^5.1.2" + scrypt-js "^3.0.0" + secp256k1 "^4.0.1" + setimmediate "^1.0.5" + +ethereumjs-abi@^0.6.8: + version "0.6.8" + resolved "https://registry.yarnpkg.com/ethereumjs-abi/-/ethereumjs-abi-0.6.8.tgz#71bc152db099f70e62f108b7cdfca1b362c6fcae" + integrity sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA== + dependencies: + bn.js "^4.11.8" + ethereumjs-util "^6.0.0" + +ethereumjs-util@7.1.5, ethereumjs-util@^7.1.4, ethereumjs-util@^7.1.5: + version "7.1.5" + resolved "https://registry.yarnpkg.com/ethereumjs-util/-/ethereumjs-util-7.1.5.tgz#9ecf04861e4fbbeed7465ece5f23317ad1129181" + integrity sha512-SDl5kKrQAudFBUe5OJM9Ac6WmMyYmXX/6sTmLZ3ffG2eY6ZIGBes3pEDxNN6V72WyOw4CPD5RomKdsa8DAAwLg== + dependencies: + "@types/bn.js" "^5.1.0" + bn.js "^5.1.2" + create-hash "^1.1.2" + ethereum-cryptography "^0.1.3" + rlp "^2.2.4" + +ethereumjs-util@^6.0.0, ethereumjs-util@^6.2.1: + version "6.2.1" + resolved "https://registry.yarnpkg.com/ethereumjs-util/-/ethereumjs-util-6.2.1.tgz#fcb4e4dd5ceacb9d2305426ab1a5cd93e3163b69" + integrity sha512-W2Ktez4L01Vexijrm5EB6w7dg4n/TgpoYU4avuT5T3Vmnw/eCRtiBrJfQYS/DCSvDIOLn2k57GcHdeBcgVxAqw== + dependencies: + "@types/bn.js" "^4.11.3" + bn.js "^4.11.0" + create-hash "^1.1.2" + elliptic "^6.5.2" + ethereum-cryptography "^0.1.3" + ethjs-util "0.1.6" + rlp "^2.2.3" + +ethers@5.7.2, ethers@^5.7.2: + version "5.7.2" + resolved "https://registry.npmjs.org/ethers/-/ethers-5.7.2.tgz" + integrity sha512-wswUsmWo1aOK8rR7DIKiWSw9DbLWe6x98Jrn8wcTflTVvaXhAMaB5zGAXy0GYQEQp9iO1iSHWVyARQm11zUtyg== + dependencies: + "@ethersproject/abi" "5.7.0" + "@ethersproject/abstract-provider" "5.7.0" + "@ethersproject/abstract-signer" "5.7.0" + "@ethersproject/address" "5.7.0" + "@ethersproject/base64" "5.7.0" + "@ethersproject/basex" "5.7.0" + "@ethersproject/bignumber" "5.7.0" + "@ethersproject/bytes" "5.7.0" + "@ethersproject/constants" "5.7.0" + "@ethersproject/contracts" "5.7.0" + "@ethersproject/hash" "5.7.0" + "@ethersproject/hdnode" "5.7.0" + "@ethersproject/json-wallets" "5.7.0" + "@ethersproject/keccak256" "5.7.0" + "@ethersproject/logger" "5.7.0" + "@ethersproject/networks" "5.7.1" + "@ethersproject/pbkdf2" "5.7.0" + "@ethersproject/properties" "5.7.0" + "@ethersproject/providers" "5.7.2" + "@ethersproject/random" "5.7.0" + "@ethersproject/rlp" "5.7.0" + "@ethersproject/sha2" "5.7.0" + "@ethersproject/signing-key" "5.7.0" + "@ethersproject/solidity" "5.7.0" + "@ethersproject/strings" "5.7.0" + "@ethersproject/transactions" "5.7.0" + "@ethersproject/units" "5.7.0" + "@ethersproject/wallet" "5.7.0" + "@ethersproject/web" "5.7.1" + "@ethersproject/wordlists" "5.7.0" + +ethjs-util@0.1.6, ethjs-util@^0.1.6: + version "0.1.6" + resolved "https://registry.yarnpkg.com/ethjs-util/-/ethjs-util-0.1.6.tgz#f308b62f185f9fe6237132fb2a9818866a5cd536" + integrity sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w== + dependencies: + is-hex-prefixed "1.0.0" + strip-hex-prefix "1.0.0" + +eventemitter3@^4.0.7: + version "4.0.7" + resolved "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz" + integrity sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw== + +evp_bytestokey@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz#7fcbdb198dc71959432efe13842684e0525acb02" + integrity sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA== + dependencies: + md5.js "^1.3.4" + safe-buffer "^5.1.1" + +eyes@^0.1.8: + version "0.1.8" + resolved "https://registry.npmjs.org/eyes/-/eyes-0.1.8.tgz" + integrity sha512-GipyPsXO1anza0AOZdy69Im7hGFCNB7Y/NGjDlZGJ3GJJLtwNSb2vrzYrTYJRrRloVx7pl+bhUaTB8yiccPvFQ== + +fast-stable-stringify@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/fast-stable-stringify/-/fast-stable-stringify-1.0.0.tgz#5c5543462b22aeeefd36d05b34e51c78cb86d313" + integrity sha512-wpYMUmFu5f00Sm0cj2pfivpmawLZ0NKdviQ4w9zJeR8JVtOpOxHmLaJuj0vxvGqMJQWyP/COUkF75/57OKyRag== + +file-uri-to-path@1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz#553a7b8446ff6f684359c445f1e37a05dacc33dd" + integrity sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw== + +fill-range@^7.0.1: + version "7.0.1" + resolved "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz" + integrity sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ== + dependencies: + to-regex-range "^5.0.1" + +find-up@5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz" + integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng== + dependencies: + locate-path "^6.0.0" + path-exists "^4.0.0" + +flat@^5.0.2: + version "5.0.2" + resolved "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz" + integrity sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ== + +follow-redirects@^1.14.0, follow-redirects@^1.14.4, follow-redirects@^1.14.8, follow-redirects@^1.14.9: + version "1.15.2" + resolved "https://registry.yarnpkg.com/follow-redirects/-/follow-redirects-1.15.2.tgz#b460864144ba63f2681096f274c4e57026da2c13" + integrity sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA== + +form-data@4.0.0, form-data@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/form-data/-/form-data-4.0.0.tgz#93919daeaf361ee529584b9b31664dc12c9fa452" + integrity sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww== + dependencies: + asynckit "^0.4.0" + combined-stream "^1.0.8" + mime-types "^2.1.12" + +fs.realpath@^1.0.0: + version "1.0.0" + resolved "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz" + integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== + +fsevents@~2.3.2: + version "2.3.2" + resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.2.tgz#8a526f78b8fdf4623b709e0b975c52c24c02fd1a" + integrity sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA== + +function-bind@^1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d" + integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A== + +get-caller-file@^2.0.5: + version "2.0.5" + resolved "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz" + integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== + +get-func-name@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.0.tgz" + integrity sha512-Hm0ixYtaSZ/V7C8FJrtZIuBBI+iSgL+1Aq82zSu8VQNB4S3Gk8e7Qs3VwBDJAhmRZcFqkl3tQu36g/Foh5I5ig== + +get-intrinsic@^1.1.1: + version "1.2.0" + resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.2.0.tgz#7ad1dc0535f3a2904bba075772763e5051f6d05f" + integrity sha512-L049y6nFOuom5wGyRc3/gdTLO94dySVKRACj1RmJZBQXlbTMhtNIgkWkUHq+jYmZvKf14EW1EoJnnjbmoHij0Q== + dependencies: + function-bind "^1.1.1" + has "^1.0.3" + has-symbols "^1.0.3" + +glob-parent@~5.1.2: + version "5.1.2" + resolved "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz" + integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== + dependencies: + is-glob "^4.0.1" + +glob@7.2.0: + version "7.2.0" + resolved "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz" + integrity sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.0.4" + once "^1.3.0" + path-is-absolute "^1.0.0" + +glob@^7.0.0, glob@^7.0.5, glob@^7.1.3: + version "7.2.3" + resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b" + integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q== + dependencies: + fs.realpath "^1.0.0" + inflight "^1.0.4" + inherits "2" + minimatch "^3.1.1" + once "^1.3.0" + path-is-absolute "^1.0.0" + +globalthis@^1.0.1: + version "1.0.3" + resolved "https://registry.yarnpkg.com/globalthis/-/globalthis-1.0.3.tgz#5852882a52b80dc301b0660273e1ed082f0b6ccf" + integrity sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA== + dependencies: + define-properties "^1.1.3" + +google-protobuf@^3.14.0, google-protobuf@^3.17.3, google-protobuf@^3.21.0: + version "3.21.2" + resolved "https://registry.yarnpkg.com/google-protobuf/-/google-protobuf-3.21.2.tgz#4580a2bea8bbb291ee579d1fefb14d6fa3070ea4" + integrity sha512-3MSOYFO5U9mPGikIYCzK0SaThypfGgS6bHqrUGXG3DPHCrb+txNqeEcns1W0lkGfk0rCyNXm7xB9rMxnCiZOoA== + +graphql-tag@^2.12.6: + version "2.12.6" + resolved "https://registry.yarnpkg.com/graphql-tag/-/graphql-tag-2.12.6.tgz#d441a569c1d2537ef10ca3d1633b48725329b5f1" + integrity sha512-FdSNcu2QQcWnM2VNvSCCDCVS5PpPqpzgFT8+GXzqJuoDd0CBncxCY278u4mhRO7tMgo2JjgJA5aZ+nWSQ/Z+xg== + dependencies: + tslib "^2.1.0" + +graphql@^16.3.0: + version "16.6.0" + resolved "https://registry.yarnpkg.com/graphql/-/graphql-16.6.0.tgz#c2dcffa4649db149f6282af726c8c83f1c7c5fdb" + integrity sha512-KPIBPDlW7NxrbT/eh4qPXz5FiFdL5UbaA0XUNz2Rp3Z3hqBSkbj0GVjwFDztsWVauZUWsbKHgMg++sk8UX0bkw== + +has-flag@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd" + integrity sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw== + +has-flag@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz" + integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== + +has-property-descriptors@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz#610708600606d36961ed04c196193b6a607fa861" + integrity sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ== + dependencies: + get-intrinsic "^1.1.1" + +has-symbols@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8" + integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A== + +has@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/has/-/has-1.0.3.tgz#722d7cbfc1f6aa8241f16dd814e011e1f41e8796" + integrity sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw== + dependencies: + function-bind "^1.1.1" + +hash-base@^3.0.0: + version "3.1.0" + resolved "https://registry.yarnpkg.com/hash-base/-/hash-base-3.1.0.tgz#55c381d9e06e1d2997a883b4a3fddfe7f0d3af33" + integrity sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA== + dependencies: + inherits "^2.0.4" + readable-stream "^3.6.0" + safe-buffer "^5.2.0" + +hash.js@1.1.7, hash.js@^1.0.0, hash.js@^1.0.3, hash.js@^1.1.7: + version "1.1.7" + resolved "https://registry.npmjs.org/hash.js/-/hash.js-1.1.7.tgz" + integrity sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA== + dependencies: + inherits "^2.0.3" + minimalistic-assert "^1.0.1" + +he@1.2.0: + version "1.2.0" + resolved "https://registry.npmjs.org/he/-/he-1.2.0.tgz" + integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw== + +hi-base32@^0.5.1: + version "0.5.1" + resolved "https://registry.yarnpkg.com/hi-base32/-/hi-base32-0.5.1.tgz#1279f2ddae2673219ea5870c2121d2a33132857e" + integrity sha512-EmBBpvdYh/4XxsnUybsPag6VikPYnN30td+vQk+GI3qpahVEG9+gTkG0aXVxTjBqQ5T6ijbWIu77O+C5WFWsnA== + +hmac-drbg@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz" + integrity sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg== + dependencies: + hash.js "^1.0.3" + minimalistic-assert "^1.0.0" + minimalistic-crypto-utils "^1.0.1" + +hoist-non-react-statics@^3.3.2: + version "3.3.2" + resolved "https://registry.yarnpkg.com/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz#ece0acaf71d62c2969c2ec59feff42a4b1a85b45" + integrity sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw== + dependencies: + react-is "^16.7.0" + +http-errors@^1.7.2: + version "1.8.1" + resolved "https://registry.yarnpkg.com/http-errors/-/http-errors-1.8.1.tgz#7c3f28577cbc8a207388455dbd62295ed07bd68c" + integrity sha512-Kpk9Sm7NmI+RHhnj6OIWDI1d6fIoFAtFt9RLaTMRlg/8w49juAStsrBgp0Dp4OdxdVbRIeKhtCUvoi/RuAhO4g== + dependencies: + depd "~1.1.2" + inherits "2.0.4" + setprototypeof "1.2.0" + statuses ">= 1.5.0 < 2" + toidentifier "1.0.1" + +http-status-codes@^2.2.0: + version "2.2.0" + resolved "https://registry.yarnpkg.com/http-status-codes/-/http-status-codes-2.2.0.tgz#bb2efe63d941dfc2be18e15f703da525169622be" + integrity sha512-feERVo9iWxvnejp3SEfm/+oNG517npqL2/PIA8ORjyOZjGC7TwCRQsZylciLS64i6pJ0wRYz3rkXLRwbtFa8Ng== + +humanize-ms@^1.2.1: + version "1.2.1" + resolved "https://registry.yarnpkg.com/humanize-ms/-/humanize-ms-1.2.1.tgz#c46e3159a293f6b896da29316d8b6fe8bb79bbed" + integrity sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ== + dependencies: + ms "^2.0.0" + +ieee754@^1.2.1: + version "1.2.1" + resolved "https://registry.yarnpkg.com/ieee754/-/ieee754-1.2.1.tgz#8eb7a10a63fff25d15a57b001586d177d1b0d352" + integrity sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA== + +inflight@^1.0.4: + version "1.0.6" + resolved "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz" + integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA== + dependencies: + once "^1.3.0" + wrappy "1" + +inherits@2, inherits@2.0.4, inherits@^2.0.1, inherits@^2.0.3, inherits@^2.0.4, inherits@~2.0.1, inherits@~2.0.3: + version "2.0.4" + resolved "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz" + integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ== + +interpret@^1.0.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e" + integrity sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA== + +is-binary-path@~2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz" + integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw== + dependencies: + binary-extensions "^2.0.0" + +is-core-module@^2.11.0: + version "2.12.0" + resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.12.0.tgz#36ad62f6f73c8253fd6472517a12483cf03e7ec4" + integrity sha512-RECHCBCd/viahWmwj6enj19sKbHfJrddi/6cBDsNTKbNq0f7VeaUkBo60BqzvPqo/W54ChS62Z5qyun7cfOMqQ== + dependencies: + has "^1.0.3" + +is-extglob@^2.1.1: + version "2.1.1" + resolved "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz" + integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ== + +is-fullwidth-code-point@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz" + integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== + +is-glob@^4.0.1, is-glob@~4.0.1: + version "4.0.3" + resolved "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz" + integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== + dependencies: + is-extglob "^2.1.1" + +is-hex-prefixed@1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/is-hex-prefixed/-/is-hex-prefixed-1.0.0.tgz#7d8d37e6ad77e5d127148913c573e082d777f554" + integrity sha512-WvtOiug1VFrE9v1Cydwm+FnXd3+w9GaeVUss5W4v/SLy3UW00vP+6iNF2SdnfiBoLy4bTqVdkftNGTUeOFVsbA== + +is-number@^7.0.0: + version "7.0.0" + resolved "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz" + integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== + +is-plain-obj@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz" + integrity sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA== + +is-unicode-supported@^0.1.0: + version "0.1.0" + resolved "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz" + integrity sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw== + +isarray@0.0.1: + version "0.0.1" + resolved "https://registry.yarnpkg.com/isarray/-/isarray-0.0.1.tgz#8a18acfca9a8f4177e09abfc6038939b05d1eedf" + integrity sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ== + +isarray@~1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11" + integrity sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ== + +isomorphic-ws@^4.0.1: + version "4.0.1" + resolved "https://registry.npmjs.org/isomorphic-ws/-/isomorphic-ws-4.0.1.tgz" + integrity sha512-BhBvN2MBpWTaSHdWRb/bwdZJ1WaehQ2L1KngkCkfLUGF0mAWAT1sQUQacEmQ0jXkFw/czDXPNQSL5u2/Krsz1w== + +jayson@^3.4.4: + version "3.7.0" + resolved "https://registry.yarnpkg.com/jayson/-/jayson-3.7.0.tgz#b735b12d06d348639ae8230d7a1e2916cb078f25" + integrity sha512-tfy39KJMrrXJ+mFcMpxwBvFDetS8LAID93+rycFglIQM4kl3uNR3W4lBLE/FFhsoUCEox5Dt2adVpDm/XtebbQ== + dependencies: + "@types/connect" "^3.4.33" + "@types/node" "^12.12.54" + "@types/ws" "^7.4.4" + JSONStream "^1.3.5" + commander "^2.20.3" + delay "^5.0.0" + es6-promisify "^5.0.0" + eyes "^0.1.8" + isomorphic-ws "^4.0.1" + json-stringify-safe "^5.0.1" + lodash "^4.17.20" + uuid "^8.3.2" + ws "^7.4.5" + +jayson@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/jayson/-/jayson-4.0.0.tgz" + integrity sha512-v2RNpDCMu45fnLzSk47vx7I+QUaOsox6f5X0CUlabAFwxoP+8MfAY0NQRFwOEYXIxm8Ih5y6OaEa5KYiQMkyAA== + dependencies: + "@types/connect" "^3.4.33" + "@types/node" "^12.12.54" + "@types/ws" "^7.4.4" + JSONStream "^1.3.5" + commander "^2.20.3" + delay "^5.0.0" + es6-promisify "^5.0.0" + eyes "^0.1.8" + isomorphic-ws "^4.0.1" + json-stringify-safe "^5.0.1" + uuid "^8.3.2" + ws "^7.4.5" + +js-base64@^3.6.1: + version "3.7.5" + resolved "https://registry.yarnpkg.com/js-base64/-/js-base64-3.7.5.tgz#21e24cf6b886f76d6f5f165bfcd69cc55b9e3fca" + integrity sha512-3MEt5DTINKqfScXKfJFrRbxkrnk2AxPWGBL/ycjz4dK8iqiSJ06UxD8jh8xuh6p10TX4t2+7FsBYVxxQbMg+qA== + +js-sha256@^0.9.0: + version "0.9.0" + resolved "https://registry.yarnpkg.com/js-sha256/-/js-sha256-0.9.0.tgz#0b89ac166583e91ef9123644bd3c5334ce9d0966" + integrity sha512-sga3MHh9sgQN2+pJ9VYZ+1LPwXOxuBJBA5nrR5/ofPfuiJBE2hnjsaN8se8JznOmGLN2p49Pe5U/ttafcs/apA== + +js-sha3@0.8.0, js-sha3@^0.8.0: + version "0.8.0" + resolved "https://registry.npmjs.org/js-sha3/-/js-sha3-0.8.0.tgz" + integrity sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q== + +js-sha512@^0.8.0: + version "0.8.0" + resolved "https://registry.yarnpkg.com/js-sha512/-/js-sha512-0.8.0.tgz#dd22db8d02756faccf19f218e3ed61ec8249f7d4" + integrity sha512-PWsmefG6Jkodqt+ePTvBZCSMFgN7Clckjd0O7su3I0+BW2QWUTJNzjktHsztGLhncP2h8mcF9V9Y2Ha59pAViQ== + +"js-tokens@^3.0.0 || ^4.0.0": + version "4.0.0" + resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-4.0.0.tgz#19203fb59991df98e3a287050d4647cdeaf32499" + integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== + +js-yaml@4.1.0: + version "4.1.0" + resolved "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz" + integrity sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA== + dependencies: + argparse "^2.0.1" + +jscrypto@^1.0.1, jscrypto@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/jscrypto/-/jscrypto-1.0.3.tgz#598febca2a939d6f679c54f56e1fe364cef30cc9" + integrity sha512-lryZl0flhodv4SZHOqyb1bx5sKcJxj0VBo0Kzb4QMAg3L021IC9uGpl0RCZa+9KJwlRGSK2C80ITcwbe19OKLQ== + +json-bigint@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/json-bigint/-/json-bigint-1.0.0.tgz#ae547823ac0cad8398667f8cd9ef4730f5b01ff1" + integrity sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ== + dependencies: + bignumber.js "^9.0.0" + +json-stringify-safe@^5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz" + integrity sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA== + +json5@^1.0.1: + version "1.0.2" + resolved "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz" + integrity sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA== + dependencies: + minimist "^1.2.0" + +jsonparse@^1.2.0: + version "1.3.1" + resolved "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz" + integrity sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg== + +jsonschema@^1.4.0: + version "1.4.1" + resolved "https://registry.yarnpkg.com/jsonschema/-/jsonschema-1.4.1.tgz#cc4c3f0077fb4542982973d8a083b6b34f482dab" + integrity sha512-S6cATIPVv1z0IlxdN+zUk5EPjkGCdnhN4wVSBlvoUO1tOLJootbo9CquNJmbIh4yikWHiUedhRYrNPn1arpEmQ== + +keccak256@^1.0.6: + version "1.0.6" + resolved "https://registry.yarnpkg.com/keccak256/-/keccak256-1.0.6.tgz#dd32fb771558fed51ce4e45a035ae7515573da58" + integrity sha512-8GLiM01PkdJVGUhR1e6M/AvWnSqYS0HaERI+K/QtStGDGlSTx2B1zTqZk4Zlqu5TxHJNTxWAdP9Y+WI50OApUw== + dependencies: + bn.js "^5.2.0" + buffer "^6.0.3" + keccak "^3.0.2" + +keccak@^3.0.0, keccak@^3.0.2: + version "3.0.3" + resolved "https://registry.yarnpkg.com/keccak/-/keccak-3.0.3.tgz#4bc35ad917be1ef54ff246f904c2bbbf9ac61276" + integrity sha512-JZrLIAJWuZxKbCilMpNz5Vj7Vtb4scDG3dMXLOsbzBmQGyjwE61BbW7bJkfKKCShXiQZt3T6sBgALRtmd+nZaQ== + dependencies: + node-addon-api "^2.0.0" + node-gyp-build "^4.2.0" + readable-stream "^3.6.0" + +libsodium-wrappers@^0.7.6: + version "0.7.11" + resolved "https://registry.yarnpkg.com/libsodium-wrappers/-/libsodium-wrappers-0.7.11.tgz#53bd20606dffcc54ea2122133c7da38218f575f7" + integrity sha512-SrcLtXj7BM19vUKtQuyQKiQCRJPgbpauzl3s0rSwD+60wtHqSUuqcoawlMDheCJga85nKOQwxNYQxf/CKAvs6Q== + dependencies: + libsodium "^0.7.11" + +libsodium@^0.7.11: + version "0.7.11" + resolved "https://registry.yarnpkg.com/libsodium/-/libsodium-0.7.11.tgz#cd10aae7bcc34a300cc6ad0ac88fcca674cfbc2e" + integrity sha512-WPfJ7sS53I2s4iM58QxY3Inb83/6mjlYgcmZs7DJsvDlnmVUwNinBCi5vBT43P6bHRy01O4zsMU2CoVR6xJ40A== + +link-module-alias@^1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/link-module-alias/-/link-module-alias-1.2.0.tgz#6a3b7b014cfe18b2759a1222fffce6a40fc120e4" + integrity sha512-ahPjXepbSVKbahTB6LxR//VHm8HPfI+QQygCH+E82spBY4HR5VPJTvlhKBc9F7muVxnS6C1rRfoPOXAbWO/fyw== + dependencies: + chalk "^2.4.1" + +locate-path@^6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz" + integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw== + dependencies: + p-locate "^5.0.0" + +lodash.values@^4.3.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/lodash.values/-/lodash.values-4.3.0.tgz#a3a6c2b0ebecc5c2cba1c17e6e620fe81b53d347" + integrity sha512-r0RwvdCv8id9TUblb/O7rYPwVy6lerCbcawrfdo9iC/1t1wsNMJknO79WNBgwkH0hIeJ08jmvvESbFpNb4jH0Q== + +lodash@^4.17.20, lodash@^4.17.21: + version "4.17.21" + resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c" + integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== + +log-symbols@4.1.0: + version "4.1.0" + resolved "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz" + integrity sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg== + dependencies: + chalk "^4.1.0" + is-unicode-supported "^0.1.0" + +long@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/long/-/long-4.0.0.tgz#9a7b71cfb7d361a194ea555241c92f7468d5bf28" + integrity sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA== + +long@^5.0.0: + version "5.2.3" + resolved "https://registry.yarnpkg.com/long/-/long-5.2.3.tgz#a3ba97f3877cf1d778eccbcb048525ebb77499e1" + integrity sha512-lcHwpNoggQTObv5apGNCTdJrO69eHOZMi4BNC+rTLER8iHAqGrUVeLh/irVIM7zTw2bOXA8T6uNPeujwOLg/2Q== + +loose-envify@^1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.4.0.tgz#71ee51fa7be4caec1a63839f7e682d8132d30caf" + integrity sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q== + dependencies: + js-tokens "^3.0.0 || ^4.0.0" + +loupe@^2.3.1: + version "2.3.6" + resolved "https://registry.npmjs.org/loupe/-/loupe-2.3.6.tgz" + integrity sha512-RaPMZKiMy8/JruncMU5Bt6na1eftNoo++R4Y+N2FrxkDVTrGvcyzFTsaGif4QTeKESheMGegbhw6iUAq+5A8zA== + dependencies: + get-func-name "^2.0.0" + +lower-case@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/lower-case/-/lower-case-2.0.2.tgz#6fa237c63dbdc4a82ca0fd882e4722dc5e634e28" + integrity sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg== + dependencies: + tslib "^2.0.3" + +make-error@^1.1.1: + version "1.3.6" + resolved "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz" + integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== + +map-obj@^4.1.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-4.3.0.tgz#9304f906e93faae70880da102a9f1df0ea8bb05a" + integrity sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ== + +md5.js@^1.3.4: + version "1.3.5" + resolved "https://registry.yarnpkg.com/md5.js/-/md5.js-1.3.5.tgz#b5d07b8e3216e3e27cd728d72f70d1e6a342005f" + integrity sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg== + dependencies: + hash-base "^3.0.0" + inherits "^2.0.1" + safe-buffer "^5.1.2" + +mime-db@1.52.0: + version "1.52.0" + resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70" + integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg== + +mime-types@^2.1.12: + version "2.1.35" + resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a" + integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw== + dependencies: + mime-db "1.52.0" + +minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz" + integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A== + +minimalistic-crypto-utils@^1.0.1: + version "1.0.1" + resolved "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz" + integrity sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg== + +minimatch@5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/minimatch/-/minimatch-5.0.1.tgz" + integrity sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g== + dependencies: + brace-expansion "^2.0.1" + +minimatch@^3.0.3, minimatch@^3.0.4, minimatch@^3.1.1: + version "3.1.2" + resolved "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz" + integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== + dependencies: + brace-expansion "^1.1.7" + +minimist@^1.2.0, minimist@^1.2.6: + version "1.2.7" + resolved "https://registry.npmjs.org/minimist/-/minimist-1.2.7.tgz" + integrity sha512-bzfL1YUZsP41gmu/qjrEk0Q6i2ix/cVeAhbCbqH9u3zYutS1cLg00qhrD0M2MVdCcx4Sc0UpP2eBWo9rotpq6g== + +minimist@^1.2.3: + version "1.2.8" + resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.8.tgz#c1a464e7693302e082a075cee0c057741ac4772c" + integrity sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA== + +mkdirp@^0.5.1: + version "0.5.6" + resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz" + integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw== + dependencies: + minimist "^1.2.6" + +mkdirp@^1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e" + integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw== + +mocha@^10.2.0: + version "10.2.0" + resolved "https://registry.npmjs.org/mocha/-/mocha-10.2.0.tgz" + integrity sha512-IDY7fl/BecMwFHzoqF2sg/SHHANeBoMMXFlS9r0OXKDssYE1M5O43wUY/9BVPeIvfH2zmEbBfseqN9gBQZzXkg== + dependencies: + ansi-colors "4.1.1" + browser-stdout "1.3.1" + chokidar "3.5.3" + debug "4.3.4" + diff "5.0.0" + escape-string-regexp "4.0.0" + find-up "5.0.0" + glob "7.2.0" + he "1.2.0" + js-yaml "4.1.0" + log-symbols "4.1.0" + minimatch "5.0.1" + ms "2.1.3" + nanoid "3.3.3" + serialize-javascript "6.0.0" + strip-json-comments "3.1.1" + supports-color "8.1.1" + workerpool "6.2.1" + yargs "16.2.0" + yargs-parser "20.2.4" + yargs-unparser "2.0.0" + +ms@2.1.2: + version "2.1.2" + resolved "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz" + integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w== + +ms@2.1.3, ms@^2.0.0: + version "2.1.3" + resolved "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz" + integrity sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA== + +mustache@^4.0.0: + version "4.2.0" + resolved "https://registry.yarnpkg.com/mustache/-/mustache-4.2.0.tgz#e5892324d60a12ec9c2a73359edca52972bf6f64" + integrity sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ== + +nan@2.14.0: + version "2.14.0" + resolved "https://registry.yarnpkg.com/nan/-/nan-2.14.0.tgz#7818f722027b2459a86f0295d434d1fc2336c52c" + integrity sha512-INOFj37C7k3AfaNTtX8RhsTw7qRy7eLET14cROi9+5HAVbbHuIWUHEauBv5qT4Av2tWasiTY1Jw6puUNqRJXQg== + +nan@^2.13.2, nan@^2.14.0: + version "2.17.0" + resolved "https://registry.yarnpkg.com/nan/-/nan-2.17.0.tgz#c0150a2368a182f033e9aa5195ec76ea41a199cb" + integrity sha512-2ZTgtl0nJsO0KQCjEpxcIr5D+Yv90plTitZt9JBfQvVJDS5seMl3FOvsh3+9CoYWXf/1l5OaZzzF6nDm4cagaQ== + +nanoid@3.3.3: + version "3.3.3" + resolved "https://registry.npmjs.org/nanoid/-/nanoid-3.3.3.tgz" + integrity sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w== + +near-api-js@^1.0.0: + version "1.1.0" + resolved "https://registry.yarnpkg.com/near-api-js/-/near-api-js-1.1.0.tgz#907e807f052c1f043c6fbf28f61872de3c02235a" + integrity sha512-qYKv1mYsaDZc2uYndhS+ttDhR9+60qFc+ZjD6lWsAxr3ZskMjRwPffDGQZYhC7BRDQMe1HEbk6d5mf+TVm0Lqg== + dependencies: + bn.js "5.2.1" + borsh "^0.7.0" + bs58 "^4.0.0" + depd "^2.0.0" + error-polyfill "^0.1.3" + http-errors "^1.7.2" + js-sha256 "^0.9.0" + mustache "^4.0.0" + node-fetch "^2.6.1" + text-encoding-utf-8 "^1.0.2" + tweetnacl "^1.0.1" + +no-case@^3.0.4: + version "3.0.4" + resolved "https://registry.yarnpkg.com/no-case/-/no-case-3.0.4.tgz#d361fd5c9800f558551a8369fc0dcd4662b6124d" + integrity sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg== + dependencies: + lower-case "^2.0.2" + tslib "^2.0.3" + +node-addon-api@^2.0.0: + version "2.0.2" + resolved "https://registry.yarnpkg.com/node-addon-api/-/node-addon-api-2.0.2.tgz#432cfa82962ce494b132e9d72a15b29f71ff5d32" + integrity sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA== + +node-addon-api@^5.0.0: + version "5.1.0" + resolved "https://registry.yarnpkg.com/node-addon-api/-/node-addon-api-5.1.0.tgz#49da1ca055e109a23d537e9de43c09cca21eb762" + integrity sha512-eh0GgfEkpnoWDq+VY8OyvYhFEzBk6jIYbRKdIlyTiAXIVJ8PyBaKb0rp7oDtoddbdoHWhq8wwr+XZ81F1rpNdA== + +node-fetch@2.6.7: + version "2.6.7" + resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.7.tgz#24de9fba827e3b4ae44dc8b20256a379160052ad" + integrity sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ== + dependencies: + whatwg-url "^5.0.0" + +node-fetch@^2.6.1, node-fetch@^2.6.7: + version "2.6.9" + resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.9.tgz#7c7f744b5cc6eb5fd404e0c7a9fec630a55657e6" + integrity sha512-DJm/CJkZkRjKKj4Zi4BsKVZh3ValV5IR5s7LVZnW+6YMh0W1BfNA8XSs6DLMGYlId5F3KnA70uu2qepcR08Qqg== + dependencies: + whatwg-url "^5.0.0" + +node-gyp-build@^4.2.0, node-gyp-build@^4.3.0: + version "4.6.0" + resolved "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.6.0.tgz" + integrity sha512-NTZVKn9IylLwUzaKjkas1e4u2DLNcV4rdYagA4PWdPwW87Bi7z+BznyKSRwS/761tV/lzCGXplWsiaMjLqP2zQ== + +noms@0.0.0: + version "0.0.0" + resolved "https://registry.yarnpkg.com/noms/-/noms-0.0.0.tgz#da8ebd9f3af9d6760919b27d9cdc8092a7332859" + integrity sha512-lNDU9VJaOPxUmXcLb+HQFeUgQQPtMI24Gt6hgfuMHRJgMRHMF/qZ4HJD3GDru4sSw9IQl2jPjAYnQrdIeLbwow== + dependencies: + inherits "^2.0.1" + readable-stream "~1.0.31" + +normalize-path@^3.0.0, normalize-path@~3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz" + integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== + +o3@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/o3/-/o3-1.0.3.tgz#192ce877a882dfa6751f0412a865fafb2da1dac0" + integrity sha512-f+4n+vC6s4ysy7YO7O2gslWZBUu8Qj2i2OUJOvjRxQva7jVjYjB29jrr9NCjmxZQR0gzrOcv1RnqoYOeMs5VRQ== + dependencies: + capability "^0.2.5" + +object-assign@^4.1.1: + version "4.1.1" + resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863" + integrity sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg== + +object-keys@^1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e" + integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA== + +once@^1.3.0: + version "1.4.0" + resolved "https://registry.npmjs.org/once/-/once-1.4.0.tgz" + integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== + dependencies: + wrappy "1" + +optimism@^0.16.2: + version "0.16.2" + resolved "https://registry.yarnpkg.com/optimism/-/optimism-0.16.2.tgz#519b0c78b3b30954baed0defe5143de7776bf081" + integrity sha512-zWNbgWj+3vLEjZNIh/okkY2EUfX+vB9TJopzIZwT1xxaMqC5hRLLraePod4c5n4He08xuXNH+zhKFFCu390wiQ== + dependencies: + "@wry/context" "^0.7.0" + "@wry/trie" "^0.3.0" + +p-limit@^3.0.2: + version "3.1.0" + resolved "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz" + integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ== + dependencies: + yocto-queue "^0.1.0" + +p-locate@^5.0.0: + version "5.0.0" + resolved "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz" + integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw== + dependencies: + p-limit "^3.0.2" + +pako@^2.0.3: + version "2.1.0" + resolved "https://registry.yarnpkg.com/pako/-/pako-2.1.0.tgz#266cc37f98c7d883545d11335c00fbd4062c9a86" + integrity sha512-w+eufiZ1WuJYgPXbV/PO3NCMEc3xqylkKHzp8bxp1uW4qaSNQUkwmLLEc3kKsfz8lpV1F8Ht3U1Cm+9Srog2ug== + +path-exists@^4.0.0: + version "4.0.0" + resolved "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz" + integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w== + +path-is-absolute@^1.0.0: + version "1.0.1" + resolved "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz" + integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg== + +path-parse@^1.0.7: + version "1.0.7" + resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735" + integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw== + +pathval@^1.1.1: + version "1.1.1" + resolved "https://registry.npmjs.org/pathval/-/pathval-1.1.1.tgz" + integrity sha512-Dp6zGqpTdETdR63lehJYPeIOqpiNBNtc7BpWSLrOje7UaIsE5aY92r/AunQA7rsXvet3lrJ3JnZX29UPTKXyKQ== + +pbkdf2@^3.0.17: + version "3.1.2" + resolved "https://registry.yarnpkg.com/pbkdf2/-/pbkdf2-3.1.2.tgz#dd822aa0887580e52f1a039dc3eda108efae3075" + integrity sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA== + dependencies: + create-hash "^1.1.2" + create-hmac "^1.1.4" + ripemd160 "^2.0.1" + safe-buffer "^5.0.1" + sha.js "^2.4.8" + +picomatch@^2.0.4, picomatch@^2.2.1: + version "2.3.1" + resolved "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz" + integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== + +prettier@^2.8.2: + version "2.8.2" + resolved "https://registry.npmjs.org/prettier/-/prettier-2.8.2.tgz" + integrity sha512-BtRV9BcncDyI2tsuS19zzhzoxD8Dh8LiCx7j7tHzrkz8GFXAexeWFdi22mjE1d16dftH2qNaytVxqiRTGlMfpw== + +process-nextick-args@~2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2" + integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag== + +prop-types@^15.7.2: + version "15.8.1" + resolved "https://registry.yarnpkg.com/prop-types/-/prop-types-15.8.1.tgz#67d87bf1a694f48435cf332c24af10214a3140b5" + integrity sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg== + dependencies: + loose-envify "^1.4.0" + object-assign "^4.1.1" + react-is "^16.13.1" + +protobufjs@^6.8.8, protobufjs@~6.11.2, protobufjs@~6.11.3: + version "6.11.3" + resolved "https://registry.yarnpkg.com/protobufjs/-/protobufjs-6.11.3.tgz#637a527205a35caa4f3e2a9a4a13ddffe0e7af74" + integrity sha512-xL96WDdCZYdU7Slin569tFX712BxsxslWwAfAhCYjQKGTq7dAU91Lomy6nLLhh/dyGhk/YH4TwTSRxTzhuHyZg== + dependencies: + "@protobufjs/aspromise" "^1.1.2" + "@protobufjs/base64" "^1.1.2" + "@protobufjs/codegen" "^2.0.4" + "@protobufjs/eventemitter" "^1.1.0" + "@protobufjs/fetch" "^1.1.0" + "@protobufjs/float" "^1.0.2" + "@protobufjs/inquire" "^1.1.0" + "@protobufjs/path" "^1.1.2" + "@protobufjs/pool" "^1.1.0" + "@protobufjs/utf8" "^1.1.0" + "@types/long" "^4.0.1" + "@types/node" ">=13.7.0" + long "^4.0.0" + +protobufjs@^7.0.0: + version "7.2.3" + resolved "https://registry.yarnpkg.com/protobufjs/-/protobufjs-7.2.3.tgz#01af019e40d9c6133c49acbb3ff9e30f4f0f70b2" + integrity sha512-TtpvOqwB5Gdz/PQmOjgsrGH1nHjAQVCN7JG4A6r1sXRWESL5rNMAiRcBQlCAdKxZcAbstExQePYG8xof/JVRgg== + dependencies: + "@protobufjs/aspromise" "^1.1.2" + "@protobufjs/base64" "^1.1.2" + "@protobufjs/codegen" "^2.0.4" + "@protobufjs/eventemitter" "^1.1.0" + "@protobufjs/fetch" "^1.1.0" + "@protobufjs/float" "^1.0.2" + "@protobufjs/inquire" "^1.1.0" + "@protobufjs/path" "^1.1.2" + "@protobufjs/pool" "^1.1.0" + "@protobufjs/utf8" "^1.1.0" + "@types/node" ">=13.7.0" + long "^5.0.0" + +randombytes@^2.1.0: + version "2.1.0" + resolved "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz" + integrity sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ== + dependencies: + safe-buffer "^5.1.0" + +react-is@^16.13.1, react-is@^16.7.0: + version "16.13.1" + resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.13.1.tgz#789729a4dc36de2999dc156dd6c1d9c18cea56a4" + integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ== + +readable-stream@^3.6.0: + version "3.6.2" + resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.2.tgz#56a9b36ea965c00c5a93ef31eb111a0f11056967" + integrity sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA== + dependencies: + inherits "^2.0.3" + string_decoder "^1.1.1" + util-deprecate "^1.0.1" + +readable-stream@~1.0.31: + version "1.0.34" + resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-1.0.34.tgz#125820e34bc842d2f2aaafafe4c2916ee32c157c" + integrity sha512-ok1qVCJuRkNmvebYikljxJA/UEsKwLl2nI1OmaqAu4/UE+h0wKCHok4XkL/gvi39OacXvw59RJUOFUkDib2rHg== + dependencies: + core-util-is "~1.0.0" + inherits "~2.0.1" + isarray "0.0.1" + string_decoder "~0.10.x" + +readable-stream@~2.3.6: + version "2.3.8" + resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.8.tgz#91125e8042bba1b9887f49345f6277027ce8be9b" + integrity sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA== + dependencies: + core-util-is "~1.0.0" + inherits "~2.0.3" + isarray "~1.0.0" + process-nextick-args "~2.0.0" + safe-buffer "~5.1.1" + string_decoder "~1.1.1" + util-deprecate "~1.0.1" + +readdirp@~3.6.0: + version "3.6.0" + resolved "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz" + integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA== + dependencies: + picomatch "^2.2.1" + +readonly-date@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/readonly-date/-/readonly-date-1.0.0.tgz#5af785464d8c7d7c40b9d738cbde8c646f97dcd9" + integrity sha512-tMKIV7hlk0h4mO3JTmmVuIlJVXjKk3Sep9Bf5OH0O+758ruuVkUy2J9SttDLm91IEX/WHlXPSpxMGjPj4beMIQ== + +rechoir@^0.6.2: + version "0.6.2" + resolved "https://registry.yarnpkg.com/rechoir/-/rechoir-0.6.2.tgz#85204b54dba82d5742e28c96756ef43af50e3384" + integrity sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw== + dependencies: + resolve "^1.1.6" + +regenerator-runtime@^0.13.11: + version "0.13.11" + resolved "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz" + integrity sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg== + +require-directory@^2.1.1: + version "2.1.1" + resolved "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz" + integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q== + +resolve@^1.1.6: + version "1.22.2" + resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.2.tgz#0ed0943d4e301867955766c9f3e1ae6d01c6845f" + integrity sha512-Sb+mjNHOULsBv818T40qSPeRiuWLyaGMa5ewydRLFimneixmVy2zdivRl+AF6jaYPC8ERxGDmFSiqui6SfPd+g== + dependencies: + is-core-module "^2.11.0" + path-parse "^1.0.7" + supports-preserve-symlinks-flag "^1.0.0" + +response-iterator@^0.2.6: + version "0.2.6" + resolved "https://registry.yarnpkg.com/response-iterator/-/response-iterator-0.2.6.tgz#249005fb14d2e4eeb478a3f735a28fd8b4c9f3da" + integrity sha512-pVzEEzrsg23Sh053rmDUvLSkGXluZio0qu8VT6ukrYuvtjVfCbDZH9d6PGXb8HZfzdNZt8feXv/jvUzlhRgLnw== + +rimraf@^3.0.0: + version "3.0.2" + resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a" + integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA== + dependencies: + glob "^7.1.3" + +ripemd160-min@0.0.6: + version "0.0.6" + resolved "https://registry.yarnpkg.com/ripemd160-min/-/ripemd160-min-0.0.6.tgz#a904b77658114474d02503e819dcc55853b67e62" + integrity sha512-+GcJgQivhs6S9qvLogusiTcS9kQUfgR75whKuy5jIhuiOfQuJ8fjqxV6EGD5duH1Y/FawFUMtMhyeq3Fbnib8A== + +ripemd160@^2.0.0, ripemd160@^2.0.1: + version "2.0.2" + resolved "https://registry.yarnpkg.com/ripemd160/-/ripemd160-2.0.2.tgz#a1c1a6f624751577ba5d07914cbc92850585890c" + integrity sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA== + dependencies: + hash-base "^3.0.0" + inherits "^2.0.1" + +rlp@^2.2.3, rlp@^2.2.4: + version "2.2.7" + resolved "https://registry.yarnpkg.com/rlp/-/rlp-2.2.7.tgz#33f31c4afac81124ac4b283e2bd4d9720b30beaf" + integrity sha512-d5gdPmgQ0Z+AklL2NVXr/IoSjNZFfTVvQWzL/AM2AOcSzYP2xjlb0AC8YyCLc41MSNf6P6QVtjgPdmVtzb+4lQ== + dependencies: + bn.js "^5.2.0" + +rpc-websockets@^7.5.1: + version "7.5.1" + resolved "https://registry.npmjs.org/rpc-websockets/-/rpc-websockets-7.5.1.tgz" + integrity sha512-kGFkeTsmd37pHPMaHIgN1LVKXMi0JD782v4Ds9ZKtLlwdTKjn+CxM9A9/gLT2LaOuEcEFGL98h1QWQtlOIdW0w== + dependencies: + "@babel/runtime" "^7.17.2" + eventemitter3 "^4.0.7" + uuid "^8.3.2" + ws "^8.5.0" + optionalDependencies: + bufferutil "^4.0.1" + utf-8-validate "^5.0.2" + +rxjs@^7.4.0, rxjs@^7.5.6, rxjs@^7.8.0: + version "7.8.1" + resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-7.8.1.tgz#6f6f3d99ea8044291efd92e7c7fcf562c4057543" + integrity sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg== + dependencies: + tslib "^2.1.0" + +safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.1.1, safe-buffer@^5.1.2, safe-buffer@^5.2.0, safe-buffer@~5.2.0: + version "5.2.1" + resolved "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz" + integrity sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ== + +safe-buffer@~5.1.0, safe-buffer@~5.1.1: + version "5.1.2" + resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d" + integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g== + +scrypt-js@3.0.1, scrypt-js@^3.0.0: + version "3.0.1" + resolved "https://registry.npmjs.org/scrypt-js/-/scrypt-js-3.0.1.tgz" + integrity sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA== + +secp256k1@3.7.1: + version "3.7.1" + resolved "https://registry.yarnpkg.com/secp256k1/-/secp256k1-3.7.1.tgz#12e473e0e9a7c2f2d4d4818e722ad0e14cc1e2f1" + integrity sha512-1cf8sbnRreXrQFdH6qsg2H71Xw91fCCS9Yp021GnUNJzWJS/py96fS4lHbnTnouLp08Xj6jBoBB6V78Tdbdu5g== + dependencies: + bindings "^1.5.0" + bip66 "^1.1.5" + bn.js "^4.11.8" + create-hash "^1.2.0" + drbg.js "^1.0.1" + elliptic "^6.4.1" + nan "^2.14.0" + safe-buffer "^5.1.2" + +secp256k1@5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/secp256k1/-/secp256k1-5.0.0.tgz#be6f0c8c7722e2481e9773336d351de8cddd12f7" + integrity sha512-TKWX8xvoGHrxVdqbYeZM9w+izTF4b9z3NhSaDkdn81btvuh+ivbIMGT/zQvDtTFWhRlThpoz6LEYTr7n8A5GcA== + dependencies: + elliptic "^6.5.4" + node-addon-api "^5.0.0" + node-gyp-build "^4.2.0" + +secp256k1@^4.0.1, secp256k1@^4.0.2, secp256k1@^4.0.3: + version "4.0.3" + resolved "https://registry.yarnpkg.com/secp256k1/-/secp256k1-4.0.3.tgz#c4559ecd1b8d3c1827ed2d1b94190d69ce267303" + integrity sha512-NLZVf+ROMxwtEj3Xa562qgv2BK5e2WNmXPiOdVIPLgs6lyTzMvBq0aWTYMI5XCP9jZMVKOcqZLw/Wc4vDkuxhA== + dependencies: + elliptic "^6.5.4" + node-addon-api "^2.0.0" + node-gyp-build "^4.2.0" + +serialize-javascript@6.0.0: + version "6.0.0" + resolved "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.0.tgz" + integrity sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag== + dependencies: + randombytes "^2.1.0" + +setimmediate@^1.0.5: + version "1.0.5" + resolved "https://registry.yarnpkg.com/setimmediate/-/setimmediate-1.0.5.tgz#290cbb232e306942d7d7ea9b83732ab7856f8285" + integrity sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA== + +setprototypeof@1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/setprototypeof/-/setprototypeof-1.2.0.tgz#66c9a24a73f9fc28cbe66b09fed3d33dcaf1b424" + integrity sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw== + +sha.js@^2.4.0, sha.js@^2.4.8: + version "2.4.11" + resolved "https://registry.yarnpkg.com/sha.js/-/sha.js-2.4.11.tgz#37a5cf0b81ecbc6943de109ba2960d1b26584ae7" + integrity sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ== + dependencies: + inherits "^2.0.1" + safe-buffer "^5.0.1" + +sha3@^2.1.1: + version "2.1.4" + resolved "https://registry.yarnpkg.com/sha3/-/sha3-2.1.4.tgz#000fac0fe7c2feac1f48a25e7a31b52a6492cc8f" + integrity sha512-S8cNxbyb0UGUM2VhRD4Poe5N58gJnJsLJ5vC7FYWGUmGhcsj4++WaIOBFVDxlG0W3To6xBuiRh+i0Qp2oNCOtg== + dependencies: + buffer "6.0.3" + +shelljs@^0.8.5: + version "0.8.5" + resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.8.5.tgz#de055408d8361bed66c669d2f000538ced8ee20c" + integrity sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow== + dependencies: + glob "^7.0.0" + interpret "^1.0.0" + rechoir "^0.6.2" + +shx@^0.3.2: + version "0.3.4" + resolved "https://registry.yarnpkg.com/shx/-/shx-0.3.4.tgz#74289230b4b663979167f94e1935901406e40f02" + integrity sha512-N6A9MLVqjxZYcVn8hLmtneQWIJtp8IKzMP4eMnx+nqkvXoqinUPCbUFLp2UcWTEIUONhlk0ewxr/jaVGlc+J+g== + dependencies: + minimist "^1.2.3" + shelljs "^0.8.5" + +snake-case@^3.0.4: + version "3.0.4" + resolved "https://registry.yarnpkg.com/snake-case/-/snake-case-3.0.4.tgz#4f2bbd568e9935abdfd593f34c691dadb49c452c" + integrity sha512-LAOh4z89bGQvl9pFfNF8V146i7o7/CqFPbqzYgP+yYzDIDeS9HaNFtXABamRW+AQzEVODcvE79ljJ+8a9YSdMg== + dependencies: + dot-case "^3.0.4" + tslib "^2.0.3" + +snakecase-keys@^5.1.2, snakecase-keys@^5.4.1: + version "5.4.5" + resolved "https://registry.yarnpkg.com/snakecase-keys/-/snakecase-keys-5.4.5.tgz#1d452c1557faf8d68f17f04a4991ccfd27afa239" + integrity sha512-qSQVcgcWk8mQUN1miVGnRMAUye1dbj9+F9PVkR7wZUXNCidQwrl/kOKmoYf+WbH2ju6c9pXnlmbS2he7pb2/9A== + dependencies: + map-obj "^4.1.0" + snake-case "^3.0.4" + type-fest "^2.5.2" + +source-map-support@^0.5.6: + version "0.5.21" + resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz" + integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w== + dependencies: + buffer-from "^1.0.0" + source-map "^0.6.0" + +source-map@^0.6.0: + version "0.6.1" + resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz" + integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g== + +"statuses@>= 1.5.0 < 2": + version "1.5.0" + resolved "https://registry.yarnpkg.com/statuses/-/statuses-1.5.0.tgz#161c7dac177659fd9811f43771fa99381478628c" + integrity sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA== + +store2@^2.12.0: + version "2.14.2" + resolved "https://registry.yarnpkg.com/store2/-/store2-2.14.2.tgz#56138d200f9fe5f582ad63bc2704dbc0e4a45068" + integrity sha512-siT1RiqlfQnGqgT/YzXVUNsom9S0H1OX+dpdGN1xkyYATo4I6sep5NmsRD/40s3IIOvlCq6akxkqG82urIZW1w== + +string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: + version "4.2.3" + resolved "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz" + integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== + dependencies: + emoji-regex "^8.0.0" + is-fullwidth-code-point "^3.0.0" + strip-ansi "^6.0.1" + +string_decoder@^1.1.1: + version "1.3.0" + resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e" + integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA== + dependencies: + safe-buffer "~5.2.0" + +string_decoder@~0.10.x: + version "0.10.31" + resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-0.10.31.tgz#62e203bc41766c6c28c9fc84301dab1c5310fa94" + integrity sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ== + +string_decoder@~1.1.1: + version "1.1.1" + resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8" + integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg== + dependencies: + safe-buffer "~5.1.0" + +strip-ansi@^6.0.0, strip-ansi@^6.0.1: + version "6.0.1" + resolved "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz" + integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== + dependencies: + ansi-regex "^5.0.1" + +strip-bom@^3.0.0: + version "3.0.0" + resolved "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz" + integrity sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA== + +strip-hex-prefix@1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/strip-hex-prefix/-/strip-hex-prefix-1.0.0.tgz#0c5f155fef1151373377de9dbb588da05500e36f" + integrity sha512-q8d4ue7JGEiVcypji1bALTos+0pWtyGlivAWyPuTkHzuTCJqrK9sWxYQZUq6Nq3cuyv3bm734IhHvHtGGURU6A== + dependencies: + is-hex-prefixed "1.0.0" + +strip-json-comments@3.1.1: + version "3.1.1" + resolved "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz" + integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig== + +superstruct@^0.14.2: + version "0.14.2" + resolved "https://registry.yarnpkg.com/superstruct/-/superstruct-0.14.2.tgz#0dbcdf3d83676588828f1cf5ed35cda02f59025b" + integrity sha512-nPewA6m9mR3d6k7WkZ8N8zpTWfenFH3q9pA2PkuiZxINr9DKB2+40wEQf0ixn8VaGuJ78AB6iWOtStI+/4FKZQ== + +superstruct@^0.15.4: + version "0.15.5" + resolved "https://registry.yarnpkg.com/superstruct/-/superstruct-0.15.5.tgz#0f0a8d3ce31313f0d84c6096cd4fa1bfdedc9dab" + integrity sha512-4AOeU+P5UuE/4nOUkmcQdW5y7i9ndt1cQd/3iUe+LTz3RxESf/W/5lg4B74HbDMMv8PHnPnGCQFH45kBcrQYoQ== + +superstruct@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/superstruct/-/superstruct-1.0.3.tgz" + integrity sha512-8iTn3oSS8nRGn+C2pgXSKPI3jmpm6FExNazNpjvqS6ZUJQCej3PUXEKM8NjHBOs54ExM+LPW/FBRhymrdcCiSg== + +supports-color@8.1.1: + version "8.1.1" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz" + integrity sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q== + dependencies: + has-flag "^4.0.0" + +supports-color@^5.3.0: + version "5.5.0" + resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f" + integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow== + dependencies: + has-flag "^3.0.0" + +supports-color@^7.1.0: + version "7.2.0" + resolved "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz" + integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw== + dependencies: + has-flag "^4.0.0" + +supports-preserve-symlinks-flag@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09" + integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w== + +symbol-observable@^2.0.3: + version "2.0.3" + resolved "https://registry.yarnpkg.com/symbol-observable/-/symbol-observable-2.0.3.tgz#5b521d3d07a43c351055fa43b8355b62d33fd16a" + integrity sha512-sQV7phh2WCYAn81oAkakC5qjq2Ml0g8ozqz03wOGnx9dDlG1de6yrF+0RAzSJD8fPUow3PTSMf2SAbOGxb93BA== + +symbol-observable@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/symbol-observable/-/symbol-observable-4.0.0.tgz#5b425f192279e87f2f9b937ac8540d1984b39205" + integrity sha512-b19dMThMV4HVFynSAM1++gBHAbk2Tc/osgLIBZMKsyqh34jb2e8Os7T6ZW/Bt3pJFdBTd2JwAnAAEQV7rSNvcQ== + +text-encoding-utf-8@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/text-encoding-utf-8/-/text-encoding-utf-8-1.0.2.tgz#585b62197b0ae437e3c7b5d0af27ac1021e10d13" + integrity sha512-8bw4MY9WjdsD2aMtO0OzOCY3pXGYNx2d2FfHRVUKkiCPDWjKuOlhLVASS+pD7VkLTVjW268LYJHwsnPFlBpbAg== + +through2@^2.0.1: + version "2.0.5" + resolved "https://registry.yarnpkg.com/through2/-/through2-2.0.5.tgz#01c1e39eb31d07cb7d03a96a70823260b23132cd" + integrity sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ== + dependencies: + readable-stream "~2.3.6" + xtend "~4.0.1" + +"through@>=2.2.7 <3": + version "2.3.8" + resolved "https://registry.npmjs.org/through/-/through-2.3.8.tgz" + integrity sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg== + +tiny-secp256k1@^1.1.3: + version "1.1.6" + resolved "https://registry.yarnpkg.com/tiny-secp256k1/-/tiny-secp256k1-1.1.6.tgz#7e224d2bee8ab8283f284e40e6b4acb74ffe047c" + integrity sha512-FmqJZGduTyvsr2cF3375fqGHUovSwDi/QytexX1Se4BPuPZpTE5Ftp5fg+EFSuEf3lhZqgCRjEG3ydUQ/aNiwA== + dependencies: + bindings "^1.3.0" + bn.js "^4.11.8" + create-hmac "^1.1.7" + elliptic "^6.4.0" + nan "^2.13.2" + +tmp@^0.2.1: + version "0.2.1" + resolved "https://registry.yarnpkg.com/tmp/-/tmp-0.2.1.tgz#8457fc3037dcf4719c251367a1af6500ee1ccf14" + integrity sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ== + dependencies: + rimraf "^3.0.0" + +to-regex-range@^5.0.1: + version "5.0.1" + resolved "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz" + integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== + dependencies: + is-number "^7.0.0" + +toidentifier@1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/toidentifier/-/toidentifier-1.0.1.tgz#3be34321a88a820ed1bd80dfaa33e479fbb8dd35" + integrity sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA== + +toml@^3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/toml/-/toml-3.0.0.tgz#342160f1af1904ec9d204d03a5d61222d762c5ee" + integrity sha512-y/mWCZinnvxjTKYhJ+pYxwD0mRLVvOtdS2Awbgxln6iEnt4rk0yBxeSBHkGJcPucRiG0e55mwWp+g/05rsrd6w== + +tr46@~0.0.3: + version "0.0.3" + resolved "https://registry.yarnpkg.com/tr46/-/tr46-0.0.3.tgz#8184fd347dac9cdc185992f3a6622e14b9d9ab6a" + integrity sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw== + +ts-invariant@^0.10.3: + version "0.10.3" + resolved "https://registry.yarnpkg.com/ts-invariant/-/ts-invariant-0.10.3.tgz#3e048ff96e91459ffca01304dbc7f61c1f642f6c" + integrity sha512-uivwYcQaxAucv1CzRp2n/QdYPo4ILf9VXgH19zEIjFx2EJufV16P0JtJVpYHy89DItG6Kwj2oIUjrcK5au+4tQ== + dependencies: + tslib "^2.1.0" + +ts-mocha@^10.0.0: + version "10.0.0" + resolved "https://registry.npmjs.org/ts-mocha/-/ts-mocha-10.0.0.tgz" + integrity sha512-VRfgDO+iiuJFlNB18tzOfypJ21xn2xbuZyDvJvqpTbWgkAgD17ONGr8t+Tl8rcBtOBdjXp5e/Rk+d39f7XBHRw== + dependencies: + ts-node "7.0.1" + optionalDependencies: + tsconfig-paths "^3.5.0" + +ts-node@7.0.1: + version "7.0.1" + resolved "https://registry.npmjs.org/ts-node/-/ts-node-7.0.1.tgz" + integrity sha512-BVwVbPJRspzNh2yfslyT1PSbl5uIk03EZlb493RKHN4qej/D06n1cEhjlOJG69oFsE7OT8XjpTUcYf6pKTLMhw== + dependencies: + arrify "^1.0.0" + buffer-from "^1.1.0" + diff "^3.1.0" + make-error "^1.1.1" + minimist "^1.2.0" + mkdirp "^0.5.1" + source-map-support "^0.5.6" + yn "^2.0.0" + +ts-node@^10.9.1: + version "10.9.1" + resolved "https://registry.npmjs.org/ts-node/-/ts-node-10.9.1.tgz" + integrity sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw== + dependencies: + "@cspotcode/source-map-support" "^0.8.0" + "@tsconfig/node10" "^1.0.7" + "@tsconfig/node12" "^1.0.7" + "@tsconfig/node14" "^1.0.0" + "@tsconfig/node16" "^1.0.2" + acorn "^8.4.1" + acorn-walk "^8.1.1" + arg "^4.1.0" + create-require "^1.1.0" + diff "^4.0.1" + make-error "^1.1.1" + v8-compile-cache-lib "^3.0.1" + yn "3.1.1" + +tsconfig-paths@^3.5.0: + version "3.14.1" + resolved "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.14.1.tgz" + integrity sha512-fxDhWnFSLt3VuTwtvJt5fpwxBHg5AdKWMsgcPOOIilyjymcYVZoCQF8fvFRezCNfblEXmi+PcM1eYHeOAgXCOQ== + dependencies: + "@types/json5" "^0.0.29" + json5 "^1.0.1" + minimist "^1.2.6" + strip-bom "^3.0.0" + +tslib@^2.0.3, tslib@^2.1.0, tslib@^2.3.0: + version "2.5.0" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.5.0.tgz#42bfed86f5787aeb41d031866c8f402429e0fddf" + integrity sha512-336iVw3rtn2BUK7ORdIAHTyxHGRIHVReokCR3XjbckJMK7ms8FysBfhLR8IXnAgy7T0PTPNBWKiH514FOW/WSg== + +tweetnacl-util@^0.15.1: + version "0.15.1" + resolved "https://registry.yarnpkg.com/tweetnacl-util/-/tweetnacl-util-0.15.1.tgz#b80fcdb5c97bcc508be18c44a4be50f022eea00b" + integrity sha512-RKJBIj8lySrShN4w6i/BonWp2Z/uxwC3h4y7xsRrpP59ZboCd0GpEVsOnMDYLMmKBpYhb5TgHzZXy7wTfYFBRw== + +tweetnacl@1.0.3, tweetnacl@^1.0.1, tweetnacl@^1.0.3: + version "1.0.3" + resolved "https://registry.npmjs.org/tweetnacl/-/tweetnacl-1.0.3.tgz" + integrity sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw== + +type-detect@^4.0.0, type-detect@^4.0.5: + version "4.0.8" + resolved "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz" + integrity sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g== + +type-fest@^2.5.2: + version "2.19.0" + resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-2.19.0.tgz#88068015bb33036a598b952e55e9311a60fd3a9b" + integrity sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA== + +typeforce@^1.11.5: + version "1.18.0" + resolved "https://registry.yarnpkg.com/typeforce/-/typeforce-1.18.0.tgz#d7416a2c5845e085034d70fcc5b6cc4a90edbfdc" + integrity sha512-7uc1O8h1M1g0rArakJdf0uLRSSgFcYexrVoKo+bzJd32gd4gDy2L/Z+8/FjPnU9ydY3pEnVPtr9FyscYY60K1g== + +typescript@^4.9.4: + version "4.9.4" + resolved "https://registry.npmjs.org/typescript/-/typescript-4.9.4.tgz" + integrity sha512-Uz+dTXYzxXXbsFpM86Wh3dKCxrQqUcVMxwU54orwlJjOpO3ao8L7j5lH+dWfTwgCwIuM9GQ2kvVotzYJMXTBZg== + +u3@^0.1.1: + version "0.1.1" + resolved "https://registry.yarnpkg.com/u3/-/u3-0.1.1.tgz#5f52044f42ee76cd8de33148829e14528494b73b" + integrity sha512-+J5D5ir763y+Am/QY6hXNRlwljIeRMZMGs0cT6qqZVVzzT3X3nFPXVyPOFRMOR4kupB0T8JnCdpWdp6Q/iXn3w== + +untildify@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/untildify/-/untildify-4.0.0.tgz#2bc947b953652487e4600949fb091e3ae8cd919b" + integrity sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw== + +utf-8-validate@^5.0.2, utf-8-validate@^5.0.5: + version "5.0.10" + resolved "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-5.0.10.tgz" + integrity sha512-Z6czzLq4u8fPOyx7TU6X3dvUZVvoJmxSQ+IcrlmagKhilxlhZgxPK6C5Jqbkw1IDUmFTM+cz9QDnnLTwDz/2gQ== + dependencies: + node-gyp-build "^4.3.0" + +util-deprecate@^1.0.1, util-deprecate@~1.0.1: + version "1.0.2" + resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf" + integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw== + +uuid@^8.3.2: + version "8.3.2" + resolved "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz" + integrity sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg== + +v8-compile-cache-lib@^3.0.1: + version "3.0.1" + resolved "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz" + integrity sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg== + +vlq@^2.0.4: + version "2.0.4" + resolved "https://registry.yarnpkg.com/vlq/-/vlq-2.0.4.tgz#6057b85729245b9829e3cc7755f95b228d4fe041" + integrity sha512-aodjPa2wPQFkra1G8CzJBTHXhgk3EVSwxSWXNPr1fgdFLUb8kvLV1iEb6rFgasIsjP82HWI6dsb5Io26DDnasA== + +webidl-conversions@^3.0.0: + version "3.0.1" + resolved "https://registry.yarnpkg.com/webidl-conversions/-/webidl-conversions-3.0.1.tgz#24534275e2a7bc6be7bc86611cc16ae0a5654871" + integrity sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ== + +whatwg-url@^5.0.0: + version "5.0.0" + resolved "https://registry.yarnpkg.com/whatwg-url/-/whatwg-url-5.0.0.tgz#966454e8765462e37644d3626f6742ce8b70965d" + integrity sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw== + dependencies: + tr46 "~0.0.3" + webidl-conversions "^3.0.0" + +wif@^2.0.6: + version "2.0.6" + resolved "https://registry.yarnpkg.com/wif/-/wif-2.0.6.tgz#08d3f52056c66679299726fade0d432ae74b4704" + integrity sha512-HIanZn1zmduSF+BQhkE+YXIbEiH0xPr1012QbFEGB0xsKqJii0/SqJjyn8dFv6y36kOznMgMB+LGcbZTJ1xACQ== + dependencies: + bs58check "<3.0.0" + +workerpool@6.2.1: + version "6.2.1" + resolved "https://registry.npmjs.org/workerpool/-/workerpool-6.2.1.tgz" + integrity sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw== + +wrap-ansi@^7.0.0: + version "7.0.0" + resolved "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz" + integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + +wrappy@1: + version "1.0.2" + resolved "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz" + integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ== + +ws@7.4.6: + version "7.4.6" + resolved "https://registry.npmjs.org/ws/-/ws-7.4.6.tgz" + integrity sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A== + +ws@^7, ws@^7.4.5, ws@^7.5.8, ws@^7.5.9: + version "7.5.9" + resolved "https://registry.npmjs.org/ws/-/ws-7.5.9.tgz" + integrity sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q== + +ws@^8.5.0: + version "8.12.0" + resolved "https://registry.npmjs.org/ws/-/ws-8.12.0.tgz" + integrity sha512-kU62emKIdKVeEIOIKVegvqpXMSTAMLJozpHZaJNDYqBjzlSYXQGviYwN1osDLJ9av68qHd4a2oSjd7yD4pacig== + +xstream@^11.14.0: + version "11.14.0" + resolved "https://registry.yarnpkg.com/xstream/-/xstream-11.14.0.tgz#2c071d26b18310523b6877e86b4e54df068a9ae5" + integrity sha512-1bLb+kKKtKPbgTK6i/BaoAn03g47PpFstlbe1BA+y3pNS/LfvcaghS5BFf9+EE1J+KwSQsEpfJvFN5GqFtiNmw== + dependencies: + globalthis "^1.0.1" + symbol-observable "^2.0.3" + +xtend@~4.0.1: + version "4.0.2" + resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54" + integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ== + +y18n@^5.0.5: + version "5.0.8" + resolved "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz" + integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA== + +yaml@^2.2.1: + version "2.2.1" + resolved "https://registry.npmjs.org/yaml/-/yaml-2.2.1.tgz" + integrity sha512-e0WHiYql7+9wr4cWMx3TVQrNwejKaEe7/rHNmQmqRjazfOP5W8PB6Jpebb5o6fIapbz9o9+2ipcaTM2ZwDI6lw== + +yargs-parser@20.2.4: + version "20.2.4" + resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.4.tgz" + integrity sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA== + +yargs-parser@^20.2.2: + version "20.2.9" + resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz" + integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w== + +yargs-parser@^21.1.1: + version "21.1.1" + resolved "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz" + integrity sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw== + +yargs-unparser@2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/yargs-unparser/-/yargs-unparser-2.0.0.tgz" + integrity sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA== + dependencies: + camelcase "^6.0.0" + decamelize "^4.0.0" + flat "^5.0.2" + is-plain-obj "^2.1.0" + +yargs@16.2.0, yargs@^16.1.0: + version "16.2.0" + resolved "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz" + integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw== + dependencies: + cliui "^7.0.2" + escalade "^3.1.1" + get-caller-file "^2.0.5" + require-directory "^2.1.1" + string-width "^4.2.0" + y18n "^5.0.5" + yargs-parser "^20.2.2" + +yargs@^17.6.2: + version "17.6.2" + resolved "https://registry.npmjs.org/yargs/-/yargs-17.6.2.tgz" + integrity sha512-1/9UrdHjDZc0eOU0HxOHoS78C69UD3JRMvzlJ7S79S2nTaWRA/whGCTV8o9e/N/1Va9YIV7Q4sOxD8VV4pCWOw== + dependencies: + cliui "^8.0.1" + escalade "^3.1.1" + get-caller-file "^2.0.5" + require-directory "^2.1.1" + string-width "^4.2.3" + y18n "^5.0.5" + yargs-parser "^21.1.1" + +yn@3.1.1: + version "3.1.1" + resolved "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz" + integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q== + +yn@^2.0.0: + version "2.0.0" + resolved "https://registry.npmjs.org/yn/-/yn-2.0.0.tgz" + integrity sha512-uTv8J/wiWTgUTg+9vLTi//leUl5vDQS6uii/emeTb2ssY7vl6QWf2fFbIIGjnhjvbdKlU0ed7QPgY1htTC86jQ== + +yocto-queue@^0.1.0: + version "0.1.0" + resolved "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz" + integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q== + +zen-observable-ts@^1.2.5: + version "1.2.5" + resolved "https://registry.yarnpkg.com/zen-observable-ts/-/zen-observable-ts-1.2.5.tgz#6c6d9ea3d3a842812c6e9519209365a122ba8b58" + integrity sha512-QZWQekv6iB72Naeake9hS1KxHlotfRpe+WGNbNx5/ta+R3DNjVO2bswf63gXlWDcs+EMd7XY8HfVQyP1X6T4Zg== + dependencies: + zen-observable "0.8.15" + +zen-observable@0.8.15: + version "0.8.15" + resolved "https://registry.yarnpkg.com/zen-observable/-/zen-observable-0.8.15.tgz#96415c512d8e3ffd920afd3889604e30b9eaac15" + integrity sha512-PQ2PC7R9rslx84ndNBZB/Dkv8V8fZEpk83RLgXtYd0fwUgEjseMn1Dgajh2x6S8QbZAFa9p2qVCEuYZNgve0dQ==