From d78d97c81578276728ca57639c0a64fae72d66d6 Mon Sep 17 00:00:00 2001 From: jonesmarvin8 <83104039+jonesmarvin8@users.noreply.github.com> Date: Mon, 15 Dec 2025 18:13:31 -0500 Subject: [PATCH] Reapply "Merge branch 'main' into simple_amm" This reverts commit 2419d4a1126afa9882b3fefbe518582ae130a817. --- Cargo.toml | 2 + common/src/sequencer_client.rs | 16 +- examples/program_deployment/Cargo.toml | 13 + examples/program_deployment/README.md | 571 +++++++++++++++++ .../program_deployment/methods/Cargo.toml | 10 + examples/program_deployment/methods/build.rs | 3 + .../methods/guest/Cargo.toml | 13 + .../methods/guest/src/bin/hello_world.rs | 60 ++ .../src/bin/hello_world_with_authorization.rs | 69 ++ .../src/bin/hello_world_with_move_function.rs | 101 +++ .../methods/guest/src/bin/simple_tail_call.rs | 64 ++ .../program_deployment/methods/src/lib.rs | 1 + .../src/bin/run_hello_world.rs | 67 ++ .../src/bin/run_hello_world_private.rs | 61 ++ .../bin/run_hello_world_through_tail_call.rs | 63 ++ .../bin/run_hello_world_with_authorization.rs | 80 +++ .../bin/run_hello_world_with_move_function.rs | 155 +++++ .../configs/debug/wallet/wallet_config.json | 3 +- integration_tests/data_changer.bin | Bin 0 -> 376260 bytes integration_tests/src/data_changer.bin | Bin 371256 -> 0 bytes integration_tests/src/lib.rs | 2 +- integration_tests/src/test_suite_map.rs | 530 +++++++++++++--- integration_tests/src/tps_test_utils.rs | 9 +- key_protocol/Cargo.toml | 1 + .../key_management/key_tree/chain_index.rs | 152 ++++- .../src/key_management/key_tree/mod.rs | 334 +++++++++- key_protocol/src/key_protocol_core/mod.rs | 42 +- nssa/core/Cargo.toml | 7 +- nssa/core/src/account.rs | 13 +- nssa/core/src/account/data.rs | 174 +++++ nssa/core/src/circuit_io.rs | 8 +- nssa/core/src/encoding.rs | 13 +- nssa/core/src/program.rs | 103 ++- nssa/program_methods/guest/Cargo.lock | 1 + .../guest/src/bin/authenticated_transfer.rs | 43 +- nssa/program_methods/guest/src/bin/pinata.rs | 18 +- .../guest/src/bin/pinata_token.rs | 40 +- .../src/bin/privacy_preserving_circuit.rs | 142 +++-- nssa/program_methods/guest/src/bin/token.rs | 202 ++++-- nssa/src/lib.rs | 7 +- .../privacy_preserving_transaction/circuit.rs | 100 ++- .../src/privacy_preserving_transaction/mod.rs | 2 + nssa/src/program.rs | 9 +- nssa/src/state.rs | 310 +++++++-- nssa/test_program_methods/guest/Cargo.lock | 1 + .../guest/src/bin/burner.rs | 13 +- .../guest/src/bin/chain_caller.rs | 10 +- .../guest/src/bin/claimer.rs | 13 +- .../guest/src/bin/data_changer.rs | 13 +- .../guest/src/bin/extra_output.rs | 3 +- .../guest/src/bin/minter.rs | 4 +- .../guest/src/bin/missing_output.rs | 8 +- .../guest/src/bin/modified_transfer.rs | 82 +++ .../guest/src/bin/nonce_changer.rs | 4 +- .../guest/src/bin/program_owner_changer.rs | 4 +- .../guest/src/bin/simple_balance_transfer.rs | 12 +- wallet/Cargo.toml | 1 + wallet/src/chain_storage.rs | 4 +- wallet/src/cli/account.rs | 14 +- wallet/src/cli/config.rs | 22 +- wallet/src/cli/mod.rs | 154 ++++- wallet/src/cli/programs/pinata.rs | 1 + wallet/src/cli/programs/token.rs | 368 +++++++---- wallet/src/config.rs | 48 ++ wallet/src/helperfunctions.rs | 19 +- wallet/src/lib.rs | 37 +- wallet/src/main.rs | 16 +- wallet/src/pinata_interactions.rs | 161 +++++ wallet/src/privacy_preserving_tx.rs | 10 +- wallet/src/program_facades/token.rs | 59 +- wallet/src/transaction_utils.rs | 592 ++++++++++++++++++ 71 files changed, 4742 insertions(+), 545 deletions(-) create mode 100644 examples/program_deployment/Cargo.toml create mode 100644 examples/program_deployment/README.md create mode 100644 examples/program_deployment/methods/Cargo.toml create mode 100644 examples/program_deployment/methods/build.rs create mode 100644 examples/program_deployment/methods/guest/Cargo.toml create mode 100644 examples/program_deployment/methods/guest/src/bin/hello_world.rs create mode 100644 examples/program_deployment/methods/guest/src/bin/hello_world_with_authorization.rs create mode 100644 examples/program_deployment/methods/guest/src/bin/hello_world_with_move_function.rs create mode 100644 examples/program_deployment/methods/guest/src/bin/simple_tail_call.rs create mode 100644 examples/program_deployment/methods/src/lib.rs create mode 100644 examples/program_deployment/src/bin/run_hello_world.rs create mode 100644 examples/program_deployment/src/bin/run_hello_world_private.rs create mode 100644 examples/program_deployment/src/bin/run_hello_world_through_tail_call.rs create mode 100644 examples/program_deployment/src/bin/run_hello_world_with_authorization.rs create mode 100644 examples/program_deployment/src/bin/run_hello_world_with_move_function.rs create mode 100644 integration_tests/data_changer.bin delete mode 100644 integration_tests/src/data_changer.bin create mode 100644 nssa/core/src/account/data.rs create mode 100644 nssa/test_program_methods/guest/src/bin/modified_transfer.rs create mode 100644 wallet/src/pinata_interactions.rs create mode 100644 wallet/src/transaction_utils.rs diff --git a/Cargo.toml b/Cargo.toml index a54b91a..dd24d98 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,7 +11,9 @@ members = [ "sequencer_core", "common", "nssa", + "nssa/core", "integration_tests/proc_macro_test_attribute", + "examples/program_deployment", ] [workspace.dependencies] diff --git a/common/src/sequencer_client.rs b/common/src/sequencer_client.rs index d3c5f23..622c0c1 100644 --- a/common/src/sequencer_client.rs +++ b/common/src/sequencer_client.rs @@ -30,16 +30,25 @@ use crate::{ pub struct SequencerClient { pub client: reqwest::Client, pub sequencer_addr: String, + pub basic_auth: Option<(String, Option)>, } impl SequencerClient { pub fn new(sequencer_addr: String) -> Result { + Self::new_with_auth(sequencer_addr, None) + } + + pub fn new_with_auth( + sequencer_addr: String, + basic_auth: Option<(String, Option)>, + ) -> Result { Ok(Self { client: Client::builder() //Add more fiedls if needed .timeout(std::time::Duration::from_secs(60)) .build()?, sequencer_addr, + basic_auth, }) } @@ -51,13 +60,16 @@ impl SequencerClient { let request = rpc_primitives::message::Request::from_payload_version_2_0(method.to_string(), payload); - let call_builder = self.client.post(&self.sequencer_addr); + let mut call_builder = self.client.post(&self.sequencer_addr); + + if let Some((username, password)) = &self.basic_auth { + call_builder = call_builder.basic_auth(username, password.as_deref()); + } let call_res = call_builder.json(&request).send().await?; let response_vall = call_res.json::().await?; - // TODO: Actually why we need separation of `result` and `error` in rpc response? #[derive(Debug, Clone, Deserialize)] #[allow(dead_code)] pub struct SequencerRpcResponse { diff --git a/examples/program_deployment/Cargo.toml b/examples/program_deployment/Cargo.toml new file mode 100644 index 0000000..21d4fc8 --- /dev/null +++ b/examples/program_deployment/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "program_deployment" +version = "0.1.0" +edition = "2024" + +[dependencies] +tokio = { workspace = true, features = ["macros"] } +wallet = { path = "../../wallet" } +nssa-core = { path = "../../nssa/core" } +nssa = { path = "../../nssa" } +key_protocol = { path = "../../key_protocol/" } +clap = "4.5.53" +serde = "1.0.228" diff --git a/examples/program_deployment/README.md b/examples/program_deployment/README.md new file mode 100644 index 0000000..1bc7ed7 --- /dev/null +++ b/examples/program_deployment/README.md @@ -0,0 +1,571 @@ +# Program deployment tutorial + +This guide walks you through running the sequencer, compiling example programs, deploying a Hello World program, and interacting with accounts. + +You'll find: +- Programs: example NSSA programs under `methods/guest/src/bin`. +- Runners: scripts to create and submit transactions to invoke these programs publicly and privately under `src/bin`. + +# 0. Install the wallet +From the project’s root directory: +```bash +cargo install --path wallet --force +``` + +# 1. Run the sequencer +From the project’s root directory, start the sequencer: +```bash +cd sequencer_runner +RUST_LOG=info cargo run $(pwd)/configs/debug +``` +Keep this terminal open. We’ll use it only to observe the node logs. + +> [!NOTE] +> If you have already ran this before you'll see a `rocksdb` directory with stored blocks. Be sure to remove that directory to follow this tutorial. + + +## Checking and setting up the wallet +For sanity let's check that the wallet can connect to it. + +```bash +wallet check-health +``` + +If this is your first time, the wallet will ask for a password. This is used as seed to deterministically generate all account keys (public and private). +For this tutorial, use: `program-tutorial` + +You should see `✅All looks good!` if everything went well. + +# 2. Compile the example programs +In a second terminal, from the `lssa` root directory, compile the example Risc0 programs: +```bash +cargo risczero build --manifest-path examples/program_deployment/methods/guest/Cargo.toml +``` +The compiled `.bin` files will appear under: +``` +examples/program_deployment/methods/guest/target/riscv32im-risc0-zkvm-elf/docker/ +``` +For convenience, export this path: +```bash +export EXAMPLE_PROGRAMS_BUILD_DIR=$(pwd)/examples/program_deployment/methods/guest/target/riscv32im-risc0-zkvm-elf/docker +``` + +> [!IMPORTANT] +> **All remaining commands must be run from the `examples/program_deployment` directory.** + +# 3. Hello world example + +The Hello world program reads an arbitrary sequence of bytes from its instruction and appends them to the data field of the input account. +Execution succeeds only if the account is: + +- Uninitialized, or +- Already owned by this program + +If uninitialized, the program will claim the account and emit the updated state. + +## Navigate to the example directory +All remaining commands must be run from: +```bash +cd examples/program_deployment +``` + +## Deploy the Program + +Use the wallet’s built-in program deployment command: +```bash +wallet deploy-program $EXAMPLE_PROGRAMS_BUILD_DIR/hello_world.bin +``` + +# 4. Public execution of the Hello world example + +## Create a Public Account + +Generate a new public account: +```bash +wallet account new public +``` + +You'll see an output similar to: +```bash +Generated new account with account_id Public/BzdBoL4JRa5M873cuWb9rbYgASr1pXyaAZ1YW9ertWH9 at path /0 +``` +The relevant part is the account id `BzdBoL4JRa5M873cuWb9rbYgASr1pXyaAZ1YW9ertWH9` + +## Check the account state +New accounts are always Uninitialized. Verify: +```bash +wallet account get --account-id Public/BzdBoL4JRa5M873cuWb9rbYgASr1pXyaAZ1YW9ertWH9 +``` +Expected output: +``` +Account is Uninitialized +``` +The `Public/` prefix tells the wallet to query the public state. + +## Execute the Hello world program +Run the example: +```bash +cargo run --bin run_hello_world \ + $EXAMPLE_PROGRAMS_BUILD_DIR/hello_world.bin \ + BzdBoL4JRa5M873cuWb9rbYgASr1pXyaAZ1YW9ertWH9 +``` +> [!NOTE] +> - Passing the `.bin` lets the script compute the program ID and build the transaction. +> - Because this program executes publicly, the node performs the execution. +> - The program will claim the account and write data into it. + +Monitor the sequencer terminal to confirm execution. + +## Inspect the updated account +After the transaction is processed, check the new state: +```bash +wallet account get --account-id Public/BzdBoL4JRa5M873cuWb9rbYgASr1pXyaAZ1YW9ertWH9 +``` +Example output: +```json +{ + "balance": 0, + "program_owner_b64": "o6C6/bbjDmN9VUC51McBpPrta8lxrx2X0iHExhX0yNU=", + "data_b64": "SG9sYSBtdW5kbyE=", + "nonce": 0 +} +``` +The `data_b64` field contains de data in Base64. +Decode it: +```bash +echo -n SG9sYSBtdW5kbyE= | base64 -d +``` +You should see `Hola mundo!`. + +# 5. Understanding the code in `hello_world.rs`. +The Hello world example demonstrates the minimal structure of an NSSA program. +Its purpose is very simple: append the instruction bytes to the data field of a single account. + +### What this program does in a nutshell +1. Reads the program inputs + - The list of pre-state accounts (`pre_states`) + - The instruction bytes (`instruction`) + - The raw instruction data (used again when writing outputs) +2. Checks that there is exactly one input account: this example operates on a single account, so it expects `pre_states` to contain exactly one entry. +3. Builds the post-state: It clones the input account and appends the instruction bytes to its data field. +4. Handles account claiming logic: If the account is uninitialized (i.e. not yet claimed by any program), its program_owner will equal `DEFAULT_PROGRAM_ID`. In that case, the program issues a claim request, meaning: "This program now owns this account." +5. Outputs the proposed state transition: `write_nssa_outputs` emits: + - The original instruction data + - The original pre-states + - The new post-states + +## Code walkthrough +1. Reading inputs: +```rust +let (ProgramInput { pre_states, instruction: greeting }, instruction_data) + = read_nssa_inputs::(); +``` +2. Extracting the single account: +```rust +let [pre_state] = pre_states + .try_into() + .unwrap_or_else(|_| panic!("Input pre states should consist of a single account")); +``` +3. Constructing the updated account post state +```rust +let mut this = pre_state.account.clone(); +let mut bytes = this.data.into_inner(); +bytes.extend_from_slice(&greeting); +this.data = bytes.try_into().expect("Data should fit within the allowed limits"); +``` +4. Instantiating the `AccountPostState` with a claiming request only if the account pre state is uninitialized: +```rust +let post_state = if post_account.program_owner == DEFAULT_PROGRAM_ID { + AccountPostState::new_claimed(post_account) +} else { + AccountPostState::new(post_account) +}; +``` +5. Emmiting the output +```rust +write_nssa_outputs(instruction_data, vec![pre_state], vec![post_state]); +``` + +# 6. Understanding the runner script `run_hello_world.rs` +The `run_hello_world.rs` example demonstrates how to construct and submit a public transaction that executes the `hello_world` program. Below is a breakdown of what the file does and how the pieces fit together. + +### 1. Wallet initialization +```rust +let wallet_config = fetch_config().await.unwrap(); +let wallet_core = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); +``` +The example loads the wallet configuration and initializes `WalletCore`. +This gives access to: +- the sequencer client, +- the wallet’s account storage. + +### 2. Parsing inputs +```rust +let program_path = std::env::args_os().nth(1).unwrap().into_string().unwrap(); +let account_id: AccountId = std::env::args_os().nth(2).unwrap().into_string().unwrap().parse().unwrap(); +``` +The program expects two arguments: +- Path to the guest binary +- AccountId of the public account to operate on + +This is the account that the program will claim and write data into. + +### 3. Loading the program bytecode +```rust +let bytecode: Vec = std::fs::read(program_path).unwrap(); +let program = Program::new(bytecode).unwrap(); +``` +The Risc0 ELF is read from disk and wrapped in a Program object, which can be used to compute the program ID. The ID is used by the node to identify which program is invoked by the transaction. + + +### 4. Preparing the instruction data +```rust +let greeting: Vec = vec![72,111,108,97,32,109,117,110,100,111,33]; +``` +The example hardcodes the ASCII bytes for `Hola mundo!`. These bytes are passed to the program as its “instruction,” which the Hello World program simply appends to the account’s data field. + +### 5. Creating the public transaction + +```rust +let nonces = vec![]; +let signing_keys = []; +let message = Message::try_new(program.id(), vec![account_id], nonces, greeting).unwrap(); +let witness_set = WitnessSet::for_message(&message, &signing_keys); +let tx = PublicTransaction::new(message, witness_set); +``` + +A public transaction consists of: +- a `Message` +- a corresponding `WitnessSet` + +For this simple example, no signing or nonces are required. The transaction includes only the program ID, the target account, and the instruction bytes. The Hello World program allows this because it does not explicitly require authorization. In the next example, we’ll see how authorization requirements are enforced and how to construct a transaction that includes signatures and nonces. + +### 6. Submitting the transaction +```rust +let response = wallet_core.sequencer_client.send_tx_public(tx).await.unwrap(); +``` +The transaction is sent to the sequencer, which processes it and updates the public state accordingly. + +Once executed, you’ll be able to query the updated account to see the newly written "Hola mundo!" data. + +# 7. Private execution of the Hello world example + +This section is very similar to the previous case: + +## Create a private account + +Generate a new private account: +```bash +wallet account new private +``` + +You'll see an output similar to: +```bash +Generated new account with account_id Private/7EDHyxejuynBpmbLuiEym9HMUyCYxZDuF8X3B89ADeMr at path /0 +``` +The relevant part for this tutorial is the account id `7EDHyxejuynBpmbLuiEym9HMUyCYxZDuF8X3B89ADeMr` + +You can check it's uninitialized with + +```bash +wallet account get --account-id Private/7EDHyxejuynBpmbLuiEym9HMUyCYxZDuF8X3B89ADeMr +``` + +## Privately executing the Hello world program + +### Execute the Hello world program +Run the example: +```bash +cargo run --bin run_hello_world_private \ + $EXAMPLE_PROGRAMS_BUILD_DIR/hello_world.bin \ + 7EDHyxejuynBpmbLuiEym9HMUyCYxZDuF8X3B89ADeMr +``` +> [!NOTE] +> - This command may take a few minutes to complete. A ZK proof of the Hello world program execution and the privacy preserving circuit are being generated. Depending on the machine this can take from 30 seconds to 4 minutes. +> - We are passing the same `hello_world.bin` binary as in the previous case with public executions. This is because the program is the same, it is the privacy context of the input account that's different. +> - Because this program executes privately, the local machine runs the program and generate the proof of execution. +> - The program will claim the private account and write data into it. + +### Syncing the new private account values +The `run_hello_world` script submitted a transaction and it was (hopefully) accepted by the node. On chain there is now a commitment to the new private account values, and the account data is stored encrypted. However, the local client hasn’t updated its private state yet. That’s why, if you try to get the private account values now, it still reads the old values from local storage instead. + +```bash +wallet account get --account-id Private/7EDHyxejuynBpmbLuiEym9HMUyCYxZDuF8X3B89ADeMr +``` + +This will still show `Account is Uninitialized`. To see the new values locally, you need to run the wallet sync command. Once the client syncs, the local store will reflect the updated account data. + +To sync private accounts run: +```bash +wallet account sync-private +``` +> [!NOTE] +> - This queries the node for transactions and goes throught the encrypted accounts. Whenever a new value is found for one of the owned private accounts, the local storage is updated. + +After this completes, running +```bash +wallet account get --account-id Private/7EDHyxejuynBpmbLuiEym9HMUyCYxZDuF8X3B89ADeMr +``` +should show something similar to +```json +{ + "balance":0, + "program_owner_b64":"dWgtNRixwjC0C8aA0NL0Iuss3Q26Dw6ECk7bzExW4bI=", + "data_b64":"SG9sYSBtdW5kbyE=", + "nonce":236788677072686551559312843688143377080 +} +``` + +## The `run_hello_world_private.rs` runner +This example extends the public `run_hello_world.rs` flow by constructing a privacy-preserving transaction instead of a public one. +Both runners load a guest program, prepare a transaction, and submit it. But the private version handles encrypted account data, nullifiers, ephemeral keys, and zk proofs. + +Unlike the public version, `run_hello_world_private.rs` must: +- prepare the private account pre-state (nullifier keys, membership proof, encrypted values) +- derive a shared secret to encrypt the post-state +- compute the correct visibility mask (initialized vs. uninitialized private account) +- execute the guest program inside the zkVM and produce a proof +- build a PrivacyPreservingTransaction composed of: +- a Message encoding commitments + encrypted post-state +- a WitnessSet embedding the zk proof + +Luckily all that complexity is hidden behind the `wallet_core.send_privacy_preserving_tx` function: +```rust + let accounts = vec![PrivacyPreservingAccount::PrivateOwned(account_id)]; + + // Construct and submit the privacy-preserving transaction + wallet_core + .send_privacy_preserving_tx( + accounts, + &Program::serialize_instruction(greeting).unwrap(), + &program, + ) + .await + .unwrap(); +``` +Check the `run_hello_world_private.rs` file to see how it is used. + +# 8. Account authorization mechanism +The Hello world example does not enforce any authorization on the input account. This means any user can execute it on any account, regardless of ownership. +NSSA provides a mechanism for programs to enforce proper authorization before an execution can succeed. The meaning of authorization differs between public and private accounts: +- Public accounts: authorization requires that the transaction is signed with the account’s signing key. +- Private accounts: authorization requires that the circuit verifies knowledge of the account’s nullifier secret key. + +From the program development perspective it is very simple: input accounts come with a flag indicating whether they has been properly authorized. And so, the only difference between the program `hello_world.rs` and `hello_world_with_authorization.rs` is in the lines + +```rust + // #### Difference with `hello_world` example here: + // Fail if the input account is not authorized + // The `is_authorized` field will be correctly populated or verified by the system if + // authorization is provided. + if !pre_state.is_authorized { + panic!("Missing required authorization"); + } + // #### +``` + +Which just checks the `is_authorized` flag and fails if it is set to false. + +# 9. Public execution of the Hello world with authorization example +The workflow to execute it publicly is very similar: + +### Deploy the program +```bash +wallet deploy-program $EXAMPLE_PROGRAMS_BUILD_DIR/hello_world_with_authorization.bin +``` + +### Create a new public account +Our previous public account is already claimed by the simple Hello world program. So we need a new one to work with this other version of the hello program +```bash +wallet account new public +``` + +Outupt: +``` +Generated new account with account_id Public/9Ppqqf8NeCX58pnr8ZqKoHvSoYGqH79dSikZAtLxKgXE at path /1 +``` + +### Run the program + +```bash +cargo run --bin run_hello_world_with_authorization \ + $EXAMPLE_PROGRAMS_BUILD_DIR/hello_world_with_authorization.bin \ + 9Ppqqf8NeCX58pnr8ZqKoHvSoYGqH79dSikZAtLxKgXE +``` + +# 10. Understanding `run_hello_world_with_authorization.rs` +From the runner script perspective, the only difference is that the signing keys are passed to the `WitnessSet` constructor for it to sign it. You can see this in the following parts of the code: + +1. Loading the sigining keys from the wallet storage +```rust + // Load signing keys to provide authorization + let signing_key = wallet_core + .storage + .user_data + .get_pub_account_signing_key(&account_id) + .expect("Input account should be a self owned public account"); +``` +2. Fetching the current public nonce. +```rust + // Construct the public transaction + // Query the current nonce from the node + let nonces = wallet_core + .get_accounts_nonces(vec![account_id]) + .await + .expect("Node should be reachable to query account data"); +``` +2. Instantiate the witness set using the signing keys +```rust + let signing_keys = [signing_key]; + let message = Message::try_new(program.id(), vec![account_id], nonces, greeting).unwrap(); + // Pass the signing key to sign the message. This will be used by the node + // to flag the pre_state as `is_authorized` when executing the program + let witness_set = WitnessSet::for_message(&message, &signing_keys); +``` + +## Seeing the mechanism in action +If everything went well you won't notice any difference with the first Hello world, because the runner takes care of signing the transaction to provide authorization and the program just succeeds. +Try using the `run_hello_world.rs` runner with the `hello_world_with_authorization.bin` program. This will fail because the runner will submit the transaction without the corresponding signature. +```bash +cargo run --bin run_hello_world \ + $EXAMPLE_PROGRAMS_BUILD_DIR/hello_world_with_authorization.bin \ + 9Ppqqf8NeCX58pnr8ZqKoHvSoYGqH79dSikZAtLxKgXE +``` + +You should see something like the following **on the node logs**. +```bash +[2025-12-11T13:43:22Z WARN sequencer_core] Error at transition ProgramExecutionFailed( + "Guest panicked: Missing required authorization", + ) +``` + +# 11. Public and private account interaction example +Previous examples only operated on public or private accounts independently. Those minimal programs were useful to introduce basic concepts, but they couldn't demonstrate how different types of accounts interact within a single program invocation. +The "Hello world with move function" introduces two operations that require one or two input accounts: +- `write`: appends arbitrary bytes to a single account. This is what we already had. +- `move_data`: reads all bytes from one account, clears it, and appends those bytes to another account. +Because these operations may involve multiple accounts, we'll see how public and private accounts can participate together in one execution. It highlights how ownership checks work, when an account needs to be claimed, and how multiple post-states are emitted when several accounts are modified. + +> [!NOTE] +> The program logic is completely agnostic to whether input accounts are public or private. It always executes the same way. +> See `methods/guest/src/bin/hello_world_with_move_function.rs`. The program just reads the instruction bytes and updates the accounts state. +> All privacy handling happens on the runner side. When constructing the transaction, the runner decides which accounts are public or private and prepares the appropriate proofs. The program itself can't differentiate between privacy modes. + +Let's start by deploying the program +```bash +wallet deploy-program $EXAMPLE_PROGRAMS_BUILD_DIR/hello_world_with_move_function.bin +``` + +Let's also create a new public account +```bash +wallet account new public +``` + +Output: +``` +Generated new account with account_id Public/95iNQMbmxMRY6jULiHYkCzCkYKPEuysvBh5kEHayDxLs at path /0/0 +``` + +Let's execute the write function + +```bash +cargo run --bin run_hello_world_with_move_function \ + $EXAMPLE_PROGRAMS_BUILD_DIR/hello_world_with_move_function.bin \ + write-public 95iNQMbmxMRY6jULiHYkCzCkYKPEuysvBh5kEHayDxLs mundo! +``` + +Let's crate a new private account. + +```bash +wallet account new private +``` + +Output: +``` +Generated new account with account_id Private/8vzkK7vsdrS2gdPhLk72La8X4FJkgJ5kJLUBRbEVkReU at path /1 +``` + +Let's execute the write function + +```bash +cargo run --bin run_hello_world_with_move_function \ + $EXAMPLE_PROGRAMS_BUILD_DIR/hello_world_with_move_function.bin \ + write-private 8vzkK7vsdrS2gdPhLk72La8X4FJkgJ5kJLUBRbEVkReU Hola +``` + +To check the values of the accounts are as expected run: +```bash +wallet account get --account-id Public/95iNQMbmxMRY6jULiHYkCzCkYKPEuysvBh5kEHayDxLs +``` +and + +```bash +wallet account sync-private +wallet account get --account-id Private/8vzkK7vsdrS2gdPhLk72La8X4FJkgJ5kJLUBRbEVkReU +``` + +and check the (base64 encoded) data values are `mundo!` and `Hola` respectively. + +Now we can execute the move function to clear the data on the public account and move it to the private account. + +```bash +cargo run --bin run_hello_world_with_move_function \ + $EXAMPLE_PROGRAMS_BUILD_DIR/hello_world_with_move_function.bin \ + move-data-public-to-private 95iNQMbmxMRY6jULiHYkCzCkYKPEuysvBh5kEHayDxLs 8vzkK7vsdrS2gdPhLk72La8X4FJkgJ5kJLUBRbEVkReU +``` + +After succeeding, re run the get and sync commands and check that the public account has empty data and the private account data is `Holamundo!`. + +# 12. Program composition: tail calls +Programs can chain calls to other programs when they return. This is the tail call or chained call mechanism. It is used by programs that depend on other programs. + +The examples include a `guest/src/bin/simple_tail_call.rs` program that shows how to trigger this mechanism. It internally calls the first Hello World program with a fixed greeting: `Hello from tail call`. + +> [!NOTE] +> This program hardcodes the ID of the Hello World program. If something fails, check that this ID matches the one produced when building the Hello World program. You can see it in the output of `cargo risczero build` from the earlier sections of this tutorial. If it differs, update the ID in `simple_tail_call.rs` and build again. + +As before, let's start by deploying the program + +```bash +wallet deploy-program $EXAMPLE_PROGRAMS_BUILD_DIR/simple_tail_call.bin +``` + +We'll use the first public account of this tutorial. The one with account id `BzdBoL4JRa5M873cuWb9rbYgASr1pXyaAZ1YW9ertWH9`. This account is already owned by the Hello world program and its data reads `Hola mundo!`. + +Let's run the tail call program + +```bash +cargo run --bin run_hello_world_through_tail_call \ + $EXAMPLE_PROGRAMS_BUILD_DIR/simple_tail_call.bin \ + BzdBoL4JRa5M873cuWb9rbYgASr1pXyaAZ1YW9ertWH9 +``` + +Once the transaction is processed, query the account values with: + +```bash +wallet account get --account-id Public/BzdBoL4JRa5M873cuWb9rbYgASr1pXyaAZ1YW9ertWH9 +``` + +You should se an output similar to + +```json +{ + "balance":0, + "program_owner_b64":"fpnW4tFY9N6llZcBHaXRwu7xe+7WZnZX9RWzhwNbk1o=", + "data_b64":"SG9sYSBtdW5kbyFIZWxsbyBmcm9tIHRhaWwgY2FsbA==", + "nonce":0 +} +``` + +Decoding the (base64 encoded) data +```bash +echo -n SG9sYSBtdW5kbyFIZWxsbyBmcm9tIHRhaWwgY2FsbA== | base64 -d +``` + +Output: +``` +Hola mundo!Hello from tail call +``` + diff --git a/examples/program_deployment/methods/Cargo.toml b/examples/program_deployment/methods/Cargo.toml new file mode 100644 index 0000000..0317d2b --- /dev/null +++ b/examples/program_deployment/methods/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "test-program-methods" +version = "0.1.0" +edition = "2024" + +[build-dependencies] +risc0-build = { version = "3.0.3" } + +[package.metadata.risc0] +methods = ["guest"] diff --git a/examples/program_deployment/methods/build.rs b/examples/program_deployment/methods/build.rs new file mode 100644 index 0000000..08a8a4e --- /dev/null +++ b/examples/program_deployment/methods/build.rs @@ -0,0 +1,3 @@ +fn main() { + risc0_build::embed_methods(); +} diff --git a/examples/program_deployment/methods/guest/Cargo.toml b/examples/program_deployment/methods/guest/Cargo.toml new file mode 100644 index 0000000..8e2a199 --- /dev/null +++ b/examples/program_deployment/methods/guest/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "programs" +version = "0.1.0" +edition = "2024" + +[workspace] + +[dependencies] +risc0-zkvm = { version = "3.0.3", features = ['std'] } +nssa-core = { path = "../../../../nssa/core" } +serde = { version = "1.0.219", default-features = false } +hex = "0.4.3" +bytemuck = "1.24.0" diff --git a/examples/program_deployment/methods/guest/src/bin/hello_world.rs b/examples/program_deployment/methods/guest/src/bin/hello_world.rs new file mode 100644 index 0000000..3391eb5 --- /dev/null +++ b/examples/program_deployment/methods/guest/src/bin/hello_world.rs @@ -0,0 +1,60 @@ +use nssa_core::program::{ + AccountPostState, DEFAULT_PROGRAM_ID, ProgramInput, read_nssa_inputs, write_nssa_outputs, +}; + +// Hello-world example program. +// +// This program reads an arbitrary sequence of bytes as its instruction +// and appends those bytes to the `data` field of the single input account. +// +// Execution succeeds only if the input account is either: +// - uninitialized, or +// - already owned by this program. +// +// In case the input account is uninitialized, the program claims it. +// +// The updated account is emitted as the sole post-state. + +type Instruction = Vec; + +fn main() { + // Read inputs + let ( + ProgramInput { + pre_states, + instruction: greeting, + }, + instruction_data, + ) = read_nssa_inputs::(); + + // Unpack the input account pre state + let [pre_state] = pre_states + .try_into() + .unwrap_or_else(|_| panic!("Input pre states should consist of a single account")); + + // Construct the post state account values + let post_account = { + let mut this = pre_state.account.clone(); + let mut bytes = this.data.into_inner(); + bytes.extend_from_slice(&greeting); + this.data = bytes + .try_into() + .expect("Data should fit within the allowed limits"); + this + }; + + // Wrap the post state account values inside a `AccountPostState` instance. + // This is used to forward the account claiming request if any + let post_state = if post_account.program_owner == DEFAULT_PROGRAM_ID { + // This produces a claim request + AccountPostState::new_claimed(post_account) + } else { + // This doesn't produce a claim request + AccountPostState::new(post_account) + }; + + // The output is a proposed state difference. It will only succeed if the pre states coincide + // with the previous values of the accounts, and the transition to the post states conforms + // with the NSSA program rules. + write_nssa_outputs(instruction_data, vec![pre_state], vec![post_state]); +} diff --git a/examples/program_deployment/methods/guest/src/bin/hello_world_with_authorization.rs b/examples/program_deployment/methods/guest/src/bin/hello_world_with_authorization.rs new file mode 100644 index 0000000..043da1b --- /dev/null +++ b/examples/program_deployment/methods/guest/src/bin/hello_world_with_authorization.rs @@ -0,0 +1,69 @@ +use nssa_core::program::{ + AccountPostState, DEFAULT_PROGRAM_ID, ProgramInput, read_nssa_inputs, write_nssa_outputs, +}; + +// Hello-world with authorization example program. +// +// This program reads an arbitrary sequence of bytes as its instruction +// and appends those bytes to the `data` field of the single input account. +// +// Execution succeeds only if the input account **is authorized** and is either: +// - uninitialized, or +// - already owned by this program. +// +// In case the input account is uninitialized, the program claims it. +// +// The updated account is emitted as the sole post-state. + +type Instruction = Vec; + +fn main() { + // Read inputs + let ( + ProgramInput { + pre_states, + instruction: greeting, + }, + instruction_data, + ) = read_nssa_inputs::(); + + // Unpack the input account pre state + let [pre_state] = pre_states + .try_into() + .unwrap_or_else(|_| panic!("Input pre states should consist of a single account")); + + // #### Difference with `hello_world` example here: + // Fail if the input account is not authorized + // The `is_authorized` field will be correctly populated or verified by the system if + // authorization is provided. + if !pre_state.is_authorized { + panic!("Missing required authorization"); + } + // #### + + // Construct the post state account values + let post_account = { + let mut this = pre_state.account.clone(); + let mut bytes = this.data.into_inner(); + bytes.extend_from_slice(&greeting); + this.data = bytes + .try_into() + .expect("Data should fit within the allowed limits"); + this + }; + + // Wrap the post state account values inside a `AccountPostState` instance. + // This is used to forward the account claiming request if any + let post_state = if post_account.program_owner == DEFAULT_PROGRAM_ID { + // This produces a claim request + AccountPostState::new_claimed(post_account) + } else { + // This doesn't produce a claim request + AccountPostState::new(post_account) + }; + + // The output is a proposed state difference. It will only succeed if the pre states coincide + // with the previous values of the accounts, and the transition to the post states conforms + // with the NSSA program rules. + write_nssa_outputs(instruction_data, vec![pre_state], vec![post_state]); +} diff --git a/examples/program_deployment/methods/guest/src/bin/hello_world_with_move_function.rs b/examples/program_deployment/methods/guest/src/bin/hello_world_with_move_function.rs new file mode 100644 index 0000000..af0d4bf --- /dev/null +++ b/examples/program_deployment/methods/guest/src/bin/hello_world_with_move_function.rs @@ -0,0 +1,101 @@ +use nssa_core::{ + account::{Account, AccountWithMetadata}, + program::{ + AccountPostState, DEFAULT_PROGRAM_ID, ProgramInput, read_nssa_inputs, write_nssa_outputs, + }, +}; + +// Hello-world with write + move_data example program. +// +// This program reads an instruction of the form `(function_id, data)` and +// dispatches to either: +// +// - `write`: appends `data` to the `data` field of a single input account. +// - `move_data`: moves all bytes from one account to another. The source account is cleared and the +// destination account receives the appended bytes. +// +// Execution succeeds only if: +// - the accounts involved are either uninitialized, or +// - already owned by this program. +// +// In case an input account is uninitialized, the program will claim it when +// producing the post-state. + +type Instruction = (u8, Vec); +const WRITE_FUNCTION_ID: u8 = 0; +const MOVE_DATA_FUNCTION_ID: u8 = 1; + +fn build_post_state(post_account: Account) -> AccountPostState { + if post_account.program_owner == DEFAULT_PROGRAM_ID { + // This produces a claim request + AccountPostState::new_claimed(post_account) + } else { + // This doesn't produce a claim request + AccountPostState::new(post_account) + } +} + +fn write(pre_state: AccountWithMetadata, greeting: Vec) -> AccountPostState { + // Construct the post state account values + let post_account = { + let mut this = pre_state.account.clone(); + let mut bytes = this.data.into_inner(); + bytes.extend_from_slice(&greeting); + this.data = bytes + .try_into() + .expect("Data should fit within the allowed limits"); + this + }; + + build_post_state(post_account) +} + +fn move_data( + from_pre: &AccountWithMetadata, + to_pre: &AccountWithMetadata, +) -> Vec { + // Construct the post state account values + let from_data: Vec = from_pre.account.data.clone().into(); + + let from_post = { + let mut this = from_pre.account.clone(); + this.data = Default::default(); + build_post_state(this) + }; + + let to_post = { + let mut this = to_pre.account.clone(); + let mut bytes = this.data.into_inner(); + bytes.extend_from_slice(&from_data); + this.data = bytes + .try_into() + .expect("Data should fit within the allowed limits"); + build_post_state(this) + }; + + vec![from_post, to_post] +} + +fn main() { + // Read input accounts. + let ( + ProgramInput { + pre_states, + instruction: (function_id, data), + }, + instruction_words, + ) = read_nssa_inputs::(); + + let post_states = match (pre_states.as_slice(), function_id, data.len()) { + ([account_pre], WRITE_FUNCTION_ID, _) => { + let post = write(account_pre.clone(), data); + vec![post] + } + ([account_from_pre, account_to_pre], MOVE_DATA_FUNCTION_ID, 0) => { + move_data(account_from_pre, account_to_pre) + } + _ => panic!("invalid params"), + }; + + write_nssa_outputs(instruction_words, pre_states, post_states); +} diff --git a/examples/program_deployment/methods/guest/src/bin/simple_tail_call.rs b/examples/program_deployment/methods/guest/src/bin/simple_tail_call.rs new file mode 100644 index 0000000..d2bb58c --- /dev/null +++ b/examples/program_deployment/methods/guest/src/bin/simple_tail_call.rs @@ -0,0 +1,64 @@ +use nssa_core::program::{ + AccountPostState, ChainedCall, ProgramId, ProgramInput, read_nssa_inputs, + write_nssa_outputs_with_chained_call, +}; + +// Tail Call example program. +// +// This program shows how to chain execution to another program using `ChainedCall`. +// It reads a single account, emits it unchanged, and then triggers a tail call +// to the Hello World program with a fixed greeting. + + +/// This needs to be set to the ID of the Hello world program. +/// To get the ID run **from the root directoy of the repository**: +/// `cargo risczero build --manifest-path examples/program_deployment/methods/guest/Cargo.toml` +/// This compiles the programs and outputs the IDs in hex that can be used to copy here. +const HELLO_WORLD_PROGRAM_ID_HEX: &str = + "7e99d6e2d158f4dea59597011da5d1c2eef17beed6667657f515b387035b935a"; + +fn hello_world_program_id() -> ProgramId { + let hello_world_program_id_bytes: [u8; 32] = hex::decode(HELLO_WORLD_PROGRAM_ID_HEX) + .unwrap() + .try_into() + .unwrap(); + bytemuck::cast(hello_world_program_id_bytes) +} + +fn main() { + // Read inputs + let ( + ProgramInput { + pre_states, + instruction: _, + }, + instruction_data, + ) = read_nssa_inputs::<()>(); + + // Unpack the input account pre state + let [pre_state] = pre_states + .clone() + .try_into() + .unwrap_or_else(|_| panic!("Input pre states should consist of a single account")); + + // Create the (unchanged) post state + let post_state = AccountPostState::new(pre_state.account.clone()); + + // Create the chained call + let chained_call_greeting: Vec = b"Hello from tail call".to_vec(); + let chained_call_instruction_data = risc0_zkvm::serde::to_vec(&chained_call_greeting).unwrap(); + let chained_call = ChainedCall { + program_id: hello_world_program_id(), + instruction_data: chained_call_instruction_data, + pre_states, + pda_seeds: vec![], + }; + + // Write the outputs + write_nssa_outputs_with_chained_call( + instruction_data, + vec![pre_state], + vec![post_state], + vec![chained_call], + ); +} diff --git a/examples/program_deployment/methods/src/lib.rs b/examples/program_deployment/methods/src/lib.rs new file mode 100644 index 0000000..1bdb308 --- /dev/null +++ b/examples/program_deployment/methods/src/lib.rs @@ -0,0 +1 @@ +include!(concat!(env!("OUT_DIR"), "/methods.rs")); diff --git a/examples/program_deployment/src/bin/run_hello_world.rs b/examples/program_deployment/src/bin/run_hello_world.rs new file mode 100644 index 0000000..a7dc0fc --- /dev/null +++ b/examples/program_deployment/src/bin/run_hello_world.rs @@ -0,0 +1,67 @@ +use nssa::{ + AccountId, PublicTransaction, + program::Program, + public_transaction::{Message, WitnessSet}, +}; +use wallet::{WalletCore, helperfunctions::fetch_config}; + +// Before running this example, compile the `hello_world.rs` guest program with: +// +// cargo risczero build --manifest-path examples/program_deployment/methods/guest/Cargo.toml +// +// Note: you must run the above command from the root of the `lssa` repository. +// Note: The compiled binary file is stored in +// methods/guest/target/riscv32im-risc0-zkvm-elf/docker/hello_world.bin +// +// +// Usage: +// cargo run --bin run_hello_world /path/to/guest/binary +// +// Example: +// cargo run --bin run_hello_world \ +// methods/guest/target/riscv32im-risc0-zkvm-elf/docker/hello_world.bin \ +// Ds8q5PjLcKwwV97Zi7duhRVF9uwA2PuYMoLL7FwCzsXE + +#[tokio::main] +async fn main() { + // Load wallet config and storage + let wallet_config = fetch_config().await.unwrap(); + let wallet_core = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); + + // Parse arguments + // First argument is the path to the program binary + let program_path = std::env::args_os().nth(1).unwrap().into_string().unwrap(); + // Second argument is the account_id + let account_id: AccountId = std::env::args_os() + .nth(2) + .unwrap() + .into_string() + .unwrap() + .parse() + .unwrap(); + + // Load the program + let bytecode: Vec = std::fs::read(program_path).unwrap(); + let program = Program::new(bytecode).unwrap(); + + // Define the desired greeting in ASCII + let greeting: Vec = vec![72, 111, 108, 97, 32, 109, 117, 110, 100, 111, 33]; + + // Construct the public transaction + // No nonces nor signing keys are needed for this example. Check out the + // `run_hello_world_with_authorization` on how to use them. + let nonces = vec![]; + let signing_keys = []; + let message = Message::try_new(program.id(), vec![account_id], nonces, greeting).unwrap(); + let witness_set = WitnessSet::for_message(&message, &signing_keys); + let tx = PublicTransaction::new(message, witness_set); + + // Submit the transaction + let _response = wallet_core + .sequencer_client + .send_tx_public(tx) + .await + .unwrap(); +} diff --git a/examples/program_deployment/src/bin/run_hello_world_private.rs b/examples/program_deployment/src/bin/run_hello_world_private.rs new file mode 100644 index 0000000..be4280b --- /dev/null +++ b/examples/program_deployment/src/bin/run_hello_world_private.rs @@ -0,0 +1,61 @@ +use nssa::{AccountId, program::Program}; +use wallet::{PrivacyPreservingAccount, WalletCore, helperfunctions::fetch_config}; + +// Before running this example, compile the `hello_world.rs` guest program with: +// +// cargo risczero build --manifest-path examples/program_deployment/methods/guest/Cargo.toml +// +// Note: you must run the above command from the root of the `lssa` repository. +// Note: The compiled binary file is stored in +// methods/guest/target/riscv32im-risc0-zkvm-elf/docker/hello_world.bin +// +// +// Usage: +// cargo run --bin run_hello_world_private /path/to/guest/binary +// +// Note: the provided account_id needs to be of a private self owned account +// +// Example: +// cargo run --bin run_hello_world_private \ +// methods/guest/target/riscv32im-risc0-zkvm-elf/docker/hello_world.bin \ +// Ds8q5PjLcKwwV97Zi7duhRVF9uwA2PuYMoLL7FwCzsXE + +#[tokio::main] +async fn main() { + // Load wallet config and storage + let wallet_config = fetch_config().await.unwrap(); + let wallet_core = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); + + // Parse arguments + // First argument is the path to the program binary + let program_path = std::env::args_os().nth(1).unwrap().into_string().unwrap(); + // Second argument is the account_id + let account_id: AccountId = std::env::args_os() + .nth(2) + .unwrap() + .into_string() + .unwrap() + .parse() + .unwrap(); + + // Load the program + let bytecode: Vec = std::fs::read(program_path).unwrap(); + let program = Program::new(bytecode).unwrap(); + + // Define the desired greeting in ASCII + let greeting: Vec = vec![72, 111, 108, 97, 32, 109, 117, 110, 100, 111, 33]; + + let accounts = vec![PrivacyPreservingAccount::PrivateOwned(account_id)]; + + // Construct and submit the privacy-preserving transaction + wallet_core + .send_privacy_preserving_tx( + accounts, + &Program::serialize_instruction(greeting).unwrap(), + &program, + ) + .await + .unwrap(); +} diff --git a/examples/program_deployment/src/bin/run_hello_world_through_tail_call.rs b/examples/program_deployment/src/bin/run_hello_world_through_tail_call.rs new file mode 100644 index 0000000..d7c91f8 --- /dev/null +++ b/examples/program_deployment/src/bin/run_hello_world_through_tail_call.rs @@ -0,0 +1,63 @@ +use nssa::{ + AccountId, PublicTransaction, + program::Program, + public_transaction::{Message, WitnessSet}, +}; +use wallet::{WalletCore, helperfunctions::fetch_config}; + +// Before running this example, compile the `simple_tail_call.rs` guest program with: +// +// cargo risczero build --manifest-path examples/program_deployment/methods/guest/Cargo.toml +// +// Note: you must run the above command from the root of the `lssa` repository. +// Note: The compiled binary file is stored in +// methods/guest/target/riscv32im-risc0-zkvm-elf/docker/simple_tail_call.bin +// +// +// Usage: +// cargo run --bin run_hello_world_through_tail_call /path/to/guest/binary +// +// Example: +// cargo run --bin run_hello_world_through_tail_call \ +// methods/guest/target/riscv32im-risc0-zkvm-elf/docker/simple_tail_call.bin \ +// Ds8q5PjLcKwwV97Zi7duhRVF9uwA2PuYMoLL7FwCzsXE + +#[tokio::main] +async fn main() { + // Load wallet config and storage + let wallet_config = fetch_config().await.unwrap(); + let wallet_core = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); + + // Parse arguments + // First argument is the path to the program binary + let program_path = std::env::args_os().nth(1).unwrap().into_string().unwrap(); + // Second argument is the account_id + let account_id: AccountId = std::env::args_os() + .nth(2) + .unwrap() + .into_string() + .unwrap() + .parse() + .unwrap(); + + // Load the program + let bytecode: Vec = std::fs::read(program_path).unwrap(); + let program = Program::new(bytecode).unwrap(); + + let instruction_data = (); + let nonces = vec![]; + let signing_keys = []; + let message = + Message::try_new(program.id(), vec![account_id], nonces, instruction_data).unwrap(); + let witness_set = WitnessSet::for_message(&message, &signing_keys); + let tx = PublicTransaction::new(message, witness_set); + + // Submit the transaction + let _response = wallet_core + .sequencer_client + .send_tx_public(tx) + .await + .unwrap(); +} diff --git a/examples/program_deployment/src/bin/run_hello_world_with_authorization.rs b/examples/program_deployment/src/bin/run_hello_world_with_authorization.rs new file mode 100644 index 0000000..21740ae --- /dev/null +++ b/examples/program_deployment/src/bin/run_hello_world_with_authorization.rs @@ -0,0 +1,80 @@ +use nssa::{ + AccountId, PublicTransaction, + program::Program, + public_transaction::{Message, WitnessSet}, +}; +use wallet::{WalletCore, helperfunctions::fetch_config}; + +// Before running this example, compile the `hello_world_with_authorization.rs` guest program with: +// +// cargo risczero build --manifest-path examples/program_deployment/methods/guest/Cargo.toml +// +// Note: you must run the above command from the root of the `lssa` repository. +// Note: The compiled binary file is stored in +// methods/guest/target/riscv32im-risc0-zkvm-elf/docker/hello_world_with_authorization.bin +// +// +// Usage: +// ./run_hello_world_with_authorization /path/to/guest/binary +// +// Note: the provided account_id needs to be of a public self owned account +// +// Example: +// cargo run --bin run_hello_world_with_authorization \ +// methods/guest/target/riscv32im-risc0-zkvm-elf/docker/hello_world_with_authorization.bin \ +// Ds8q5PjLcKwwV97Zi7duhRVF9uwA2PuYMoLL7FwCzsXE + +#[tokio::main] +async fn main() { + // Load wallet config and storage + let wallet_config = fetch_config().await.unwrap(); + let wallet_core = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); + + // Parse arguments + // First argument is the path to the program binary + let program_path = std::env::args_os().nth(1).unwrap().into_string().unwrap(); + // Second argument is the account_id + let account_id: AccountId = std::env::args_os() + .nth(2) + .unwrap() + .into_string() + .unwrap() + .parse() + .unwrap(); + + // Load the program + let bytecode: Vec = std::fs::read(program_path).unwrap(); + let program = Program::new(bytecode).unwrap(); + + // Load signing keys to provide authorization + let signing_key = wallet_core + .storage + .user_data + .get_pub_account_signing_key(&account_id) + .expect("Input account should be a self owned public account"); + + // Define the desired greeting in ASCII + let greeting: Vec = vec![72, 111, 108, 97, 32, 109, 117, 110, 100, 111, 33]; + + // Construct the public transaction + // Query the current nonce from the node + let nonces = wallet_core + .get_accounts_nonces(vec![account_id]) + .await + .expect("Node should be reachable to query account data"); + let signing_keys = [signing_key]; + let message = Message::try_new(program.id(), vec![account_id], nonces, greeting).unwrap(); + // Pass the signing key to sign the message. This will be used by the node + // to flag the pre_state as `is_authorized` when executing the program + let witness_set = WitnessSet::for_message(&message, &signing_keys); + let tx = PublicTransaction::new(message, witness_set); + + // Submit the transaction + let _response = wallet_core + .sequencer_client + .send_tx_public(tx) + .await + .unwrap(); +} diff --git a/examples/program_deployment/src/bin/run_hello_world_with_move_function.rs b/examples/program_deployment/src/bin/run_hello_world_with_move_function.rs new file mode 100644 index 0000000..77c2597 --- /dev/null +++ b/examples/program_deployment/src/bin/run_hello_world_with_move_function.rs @@ -0,0 +1,155 @@ +use clap::{Parser, Subcommand}; +use nssa::{PublicTransaction, program::Program, public_transaction}; +use wallet::{PrivacyPreservingAccount, WalletCore, helperfunctions::fetch_config}; + +// Before running this example, compile the `hello_world_with_move_function.rs` guest program with: +// +// cargo risczero build --manifest-path examples/program_deployment/methods/guest/Cargo.toml +// +// Note: you must run the above command from the root of the `lssa` repository. +// Note: The compiled binary file is stored in +// methods/guest/target/riscv32im-risc0-zkvm-elf/docker/hello_world_with_move_function.bin +// +// +// Usage: +// cargo run --bin run_hello_world_with_move_function /path/to/guest/binary +// +// Example: +// cargo run --bin run_hello_world_with_move_function \ +// methods/guest/target/riscv32im-risc0-zkvm-elf/docker/hello_world_with_move_function.bin \ +// write-public Ds8q5PjLcKwwV97Zi7duhRVF9uwA2PuYMoLL7FwCzsXE Hola + +type Instruction = (u8, Vec); +const WRITE_FUNCTION_ID: u8 = 0; +const MOVE_DATA_FUNCTION_ID: u8 = 1; + +#[derive(Parser, Debug)] +struct Cli { + /// Path to program binary + program_path: String, + + #[command(subcommand)] + command: Command, +} + +#[derive(Subcommand, Debug)] +enum Command { + /// Write instruction into one account + WritePublic { + account_id: String, + greeting: String, + }, + WritePrivate { + account_id: String, + greeting: String, + }, + /// Move data between two accounts + MoveDataPublicToPublic { + from: String, + to: String, + }, + MoveDataPublicToPrivate { + from: String, + to: String, + }, +} + +#[tokio::main] +async fn main() { + let cli = Cli::parse(); + + // Load the program + let bytecode: Vec = std::fs::read(cli.program_path).unwrap(); + let program = Program::new(bytecode).unwrap(); + + // Load wallet config and storage + let wallet_config = fetch_config().await.unwrap(); + let wallet_core = WalletCore::start_from_config_update_chain(wallet_config) + .await + .unwrap(); + + match cli.command { + Command::WritePublic { + account_id, + greeting, + } => { + let instruction: Instruction = (WRITE_FUNCTION_ID, greeting.into_bytes()); + let account_id = account_id.parse().unwrap(); + let nonces = vec![]; + let message = public_transaction::Message::try_new( + program.id(), + vec![account_id], + nonces, + instruction, + ) + .unwrap(); + let witness_set = public_transaction::WitnessSet::for_message(&message, &[]); + let tx = PublicTransaction::new(message, witness_set); + + // Submit the transaction + let _response = wallet_core + .sequencer_client + .send_tx_public(tx) + .await + .unwrap(); + } + Command::WritePrivate { + account_id, + greeting, + } => { + let instruction: Instruction = (WRITE_FUNCTION_ID, greeting.into_bytes()); + let account_id = account_id.parse().unwrap(); + let accounts = vec![PrivacyPreservingAccount::PrivateOwned(account_id)]; + + wallet_core + .send_privacy_preserving_tx( + accounts, + &Program::serialize_instruction(instruction).unwrap(), + &program, + ) + .await + .unwrap(); + } + Command::MoveDataPublicToPublic { from, to } => { + let instruction: Instruction = (MOVE_DATA_FUNCTION_ID, vec![]); + let from = from.parse().unwrap(); + let to = to.parse().unwrap(); + let nonces = vec![]; + let message = public_transaction::Message::try_new( + program.id(), + vec![from, to], + nonces, + instruction, + ) + .unwrap(); + let witness_set = public_transaction::WitnessSet::for_message(&message, &[]); + let tx = PublicTransaction::new(message, witness_set); + + // Submit the transaction + let _response = wallet_core + .sequencer_client + .send_tx_public(tx) + .await + .unwrap(); + } + Command::MoveDataPublicToPrivate { from, to } => { + let instruction: Instruction = (MOVE_DATA_FUNCTION_ID, vec![]); + let from = from.parse().unwrap(); + let to = to.parse().unwrap(); + + let accounts = vec![ + PrivacyPreservingAccount::Public(from), + PrivacyPreservingAccount::PrivateOwned(to), + ]; + + wallet_core + .send_privacy_preserving_tx( + accounts, + &Program::serialize_instruction(instruction).unwrap(), + &program, + ) + .await + .unwrap(); + } + }; +} diff --git a/integration_tests/configs/debug/wallet/wallet_config.json b/integration_tests/configs/debug/wallet/wallet_config.json index ac4bae8..ad7b279 100644 --- a/integration_tests/configs/debug/wallet/wallet_config.json +++ b/integration_tests/configs/debug/wallet/wallet_config.json @@ -542,5 +542,6 @@ } } } - ] + ], + "basic_auth": null } \ No newline at end of file diff --git a/integration_tests/data_changer.bin b/integration_tests/data_changer.bin new file mode 100644 index 0000000000000000000000000000000000000000..eb28a627bac90378b6edd52dcf248751d866b6a1 GIT binary patch literal 376260 zcmeFa3wT`Bb@;o_oH=JSBUzSxWXTv~WF1MCW#i%wpgh`i23rP0UQRHCv}rKIBS}*p zDJJi9hNF?NAp~JOq%b1zk6@|efq|8_C9;Bz4m&qwfDU5)H9bEN~s3^_4;A z-}bz7nPEsv@Gqi%9rVk!sMC0K$)8%f;WX8vVyaWss<^UwB5kM9Q~sXe|MC|N|Hem? z{~4;05BZaJ0YtY8AT=%eFFP-yncBI_g#sB0_#@DcwTmJB$KVaYw82AGQ{(yl$ zVBr6o7;p^Z6}Mwr)NRW}-PUzcw`H#7E?R853)80CwZe2eSD9|d)ut1*l-ssVWoqm; zKWZyyjitOno^=|^v5JOc8-{N;C_mnyHoRA<1KC2+Y%dxkmdg71)haVAlozz1uk4*r@xpig-c7*0 z?wGav(GuL*2W5=zxXL>5PpeF0`wXwmFdPfqS~<0$MdNjg*=`t_ne8*o_Oy|yvu2s| zbMz@z^vT{^1G6))A^lG?u2d>A{(Y%@XCF)Lyx+PB`glmW9XpiQQjD6=lh>Axn)8jQH@|3_ zT{+Y1N}J%(^cEB&(4BR8RzW*U)yT3|<@fDWj=e47V+1nxl*;G6)ey7^o=z1UsBgF} zx2h`--ucov4A&S}9(?*Y)$g^)ST*B)^gD;D` zrer)*a9bX;V%@Yws{6lJ!yUj}*yykhaLc$SKUdxFB3a9CtDjxPvk$)to_^{snl{^A zn49f(t()z3&OOQPSbUP(mOjaCU2&4zvg#yv(bXr?ej@EBx}5_jx*gk2)cm?|TXYPo zxQbs}4EQN`0{l8t_%+~F)o-@vPAKzg!|+w`Dg6#k9sBs{CkbzktzF8R=Ad- z3d@~voa}W~asg{pU_14HTEi&xHdtW(w4O`G)l z{tY{T;p$^y(Bq^&Q#H=);j5sz0EUlUI(O`*TId-0Ga(GwYpdR!IeZPg8@&6G)voaK zSay?sU-R-Jk(bh5flm#C`b5<@4a3*M$H6!kt#5;$ZQsgS8}L;QWV66)*k#-|4S&k) zN!w#JR)@KKg$-X<^euc6+8ggXUHTfau_%4tIV}bpvGH-$YG8!`_;Y4Yu4b&xYBS%pt_FDH<9)MN0&l$Bw{iG0z#9kNHt$_4 z;=o(cxA1Y`9q&6!#x)Ya+h+DmOSoMFQD9Dtk6rjEFel1m&(Sa^#_FwBvu9TV+NOWH zwxa)Kz+GGFKQ?_h0^GI0LjQHOZinMHtYfW5BVziBuM>~&)i>A#}RZIk}R%KjGt z|9Jmd!#40w0WU4UKgDg;@K322|3kn(r9A$e;Tmv0Wz3fTyQa7;8vgo<{vQPX`f~r7 z(mz+v9?^eYy}M`td16eh=zjt5Pc8SKF8$L}#}d{Y;GgO)l>Wua{^tSzc>mcN{s!<* z|7i{2pZ>Xqit$$fe?xivCh1>n0ROXrzXANyKRvCY|GR;ITDgCN^v_KL|MXus4g3rI z(<}O)3;ff|{by4z&{=Q3;dP+&j$YS{*BV#aKQge;CH~k!0%Ly-vj(kdHgv- z4@C#~n}FW|{{nwwMgKE_zp>nZrly}p@K67Bjo=^sWX!1O|7XBIqugK9TY3ic(+K=C zz`xi+mHqz&_{aOt9#+8L1pcQ3e-rqpf3B%w{I>#sQ+fO*>0fMuej0$k3H;MP-CWWC z4B&4r_ivE?xn}TR5B$yGU*Mlv(LV|NGfVxk$&d-@nc%+;_-BHDfxoiT_%`4A&b-146o%5Q~dg`m^)b?G%Yb&i~-OOOW zdXIB0&~C6_HPz#aO_+_sD>ig%V-wogc2;#Cu?15R_=7%13_Cdn?L?~ki2YZ>NddcY z94BIXxe6MpuphCTPr`0K3A_0ubG~sBbT}Kkc{X;O|5eJI`B~KG8hIIMF+$ zILk4NIbugMb_{$2hf#yw_%d<rF&Ufg6`RfK|x-E-ObX$#C zA>1#8{I6*x*vr)OA_KhT#<+c0GyI<(ypDbR1KJqZNU;7yU@w=(O~1joh5wdu&2uWo zRi$z7{66bRupY)WYJvBE#^GJ@2IHpoYj`WijST-JfcL}S1247Ur53y}?$Zax$6fUX z;})LL@Sa-%Z({i0f^qL;T%!*B)`8zT;Qi_NxY*{ekKcdS@K%mnH~gazUcoQp8dJdU z6yW{I__*t4z5cj`-Fn=m74SwY$IVUg+KY^9)C2ER)pV=#G_ZyS{G1OOag zfAj?KOaq>2z(b#tzgOL7tN2Tg0nc>cnGQVD8TYa3J_Uj2QQ)DE;Q)`rxQ|x%`JuqG z19%+Zp^wqXxTDp5o)LKd8F(6jrxAGQbMhnAeGUpd1>l(hJTri22ICg0`zUOLufXBc?sV<5ZJ@c5m>)qUP8@O-oS*+nw{w(4hB$$VR@pJiqIZ&W|K zS;qT%^|QNVya%eEZI$uvuYOjL@wQYy`=N|?Z}qchWW0N-pBPA=kg6eH$5gE7;F*_kuEPVA%By}-a29R~BIl{YWPd_~3?uz}YGUfb>1WxJis z)%ASTU1$&+oMvU}5_7!4sKl`%%pc)-#9d@yTN@GwG<{nc8v>vHdXKn@tkJQF0p2l6 zJgq@xqFW>uM=U5!EGTE13yY>6uhkHIGDceI*o2Ptq&|->492h+W9EG#N2H(W=c6j{ zq19K-cE+2}c=L0n$9T@_87k9c)yv$Oy8H0GTT~{oW!4+QU78cP%XTtxKp7ugn&8p| zm!{j&W)VZP+_qaS@M?MU(iV8Nz$9rcR>85SZ&DrLnqV2Xk z%l^Lr?xV!t8i~K1$39-7+=bT=f7`)#Y|*ZV!0Qh1`XsTqEc2$JiyX1J673M5QU$}C z&+~;jjUQlQPfsJRhuz(>DeAQp<7Qhf?m^4oFpfP@V|L|gysmVOxxlEwo`{*ywYM-G zgAWp7M|2a5b8P$7fLHonb*!igVsZuh=r*6d6uSt#=(w50w%k_WYulmeT3{Hfj~^Br z*~t?-vf^sP%@XrS{S&-*_}KAU*w@mY7OtYt5033~YDJ&y6|%p2o;mRskp<7QjswKA z@nv!|iDzTq%ss(fw7A(_m~JMX-RyR*!Y{hInf7Mdo86XyX3f)mv3F~pCaw)_)%dZL z+MqP7-|^avI!#Akme`MhO@(dMfxKver(5Bdwq5Yd_`U!S_F`(8U;EM##=_q>Y8+cd zH(Vs+sUJh9b?if(*Hx^eJxY6hMf+1c16M|L{8?dlW^L^S<>@#+CS;rdM?? z^f?~CnS&qLZq#QYmMt;yjJh-?@UvI!6R=|!`sep4=czvBKV=K8C^xc0ZHzprT=QA{ zxffW|L!~{mGdD)xqW6&f(>$m5P;F$qw>Y&D!)1=X``;13r6N9i9m>Op@E2<`wndDG zcvE~a>nvzm2yl`5u9KL{I(cR#7@PMrjtV>J+gR%B(-!t0brOrGPtgAn$C|6h9`Bp| zXLH6ty*Hy+?>4f&84oFQ#$3Lq>&>QB^+f>{Oq{bvo~%o zdp_*C&7199{0ZE^4HV%$4(MciDnD()@0I&Qu@7x&&hEpEPNZrpp%;<&dw z9rxGgmD6M!{%w6ma^IjD+P71A=kBU8-?_KOd*|~t=DUozb6dZ1X4V+~m#;S*$5Xy< z8qS=XjO1ne)zJPLBYFAz)zIZ%Q0Cd|YP_=tYP>VI)tF0)HO|RjQvRJ&4gV`^3}^O@ z%KuuO;hgkEV<_{qk$mnYW9W*{8ObaE&hXx|qQ+aks>VC_YUX9HzkI#&Z;8lU@~-l~ zS}X4x$)D92Lmy$TpT1<6OQzL$@0nXO^wG~5-nol;kNvvyODZ{bWx4;*m5k4tlKXe6 zfM%U$Vv1@8~URIz16u5 zU4lMYSd7vxK9(3IYcd?(cX%H=FO8jtz1LB6 zcz-(YPv`yVyg!}ySr2Q{>)FM6SX=A!^}Iio_owoH+5YAIsk~p$`}MqE&-?Yfk6p11 z`=VIG{K$;GHN0QL``8)Nh?g4h26}H?K5XE-$O~e>$ijdh)|2l*C%47O*~G}%#N3)o zV#xQICUOq>J`?#q6Zzh3cIBFp@A&sdv$vqwgnV!E7N(obQ;a5L;|b$3ep#4z8JF>a zE=`@FWyQg#hXUC<-Y<~%S>xE}m2x|UoqOj$FxP9?3h1;Px^0~@H}@zlXQQ@lO5PA% zZ(`p#_TeM$-J|e-j{gUGU-DtT6$@os>bGWlPK_YHbRJP+w(aRq-rkCw+9dfV13Vbu z!C>BqUL*Y->;)~`TB8&8@!E^nXGS3ZLcKN7Sd95w_6oZy7b&kJ5w4@_n01K#668Y5 zYf#T4bH{C%uMNr?$k!d5n%O_d{x_&@TWq9jffrd6c?emo*A-!1k}EThSyM!>sjA&1 zFU5MW{RZGe*0yY#;VqkMm}f0EytDQqPo7ua*@oerxl3)dM9xQv(=`%XVNMI#FFK5Q zH%87w54<2as~TV6bnDQ0#8KJ5QmliRL5}^(>2-(p*mJB`VwdH0jombQ5c&EW*77oR z0srTa1MA@Lxfb>|@*$0!Sb^=d3LEok^3OT)&+EuP516I=mC#T3dV?IZtumKvRwG|A zR3;m3=-$_=%+!o60-sN=N^Fe{S*^SOI79BhZC#8_1Wr2GtNC#?QVXtY4^H)O_^fj3 zvc|}A@{eocHQnc6`y>)Cq1UjTSyS%|N0Qc{;Y>M+Sj~EDwE=_q67C}S)xzGji{U;q zpVq@!@rNUsIjiH|!lIG6?5n1EN>Mp0zppYMf1p9=cC7L1FXJDCy3P<=XfbxqORgf< z-o|>_KgNbOO5>yZ8e}bnA2GJ!y)$i$*{fgidR9nGE$Yagz)R)zF^9%|N0EJs(zZ$K za>>g|o)cMs4U@yZT!-JVP5HZTBvuCRGz}QUHVwB4T4;tAlihATtJ#9pE`{k$)~iZ}>Fi2Lk+nckmO+t1o0`TH@JdZ``O2qRn;_$9Cs1{&2}fE)C5EmWtu&q3*Jdp(5#A)r$k;lvs=-30!Q&>^(d z@ubS!7|@Tuz8xCE&epuDUh`UtCNyMv;1L?amn%k~p@`R&jzB{q2czTqtFK<*8sC@H zJlfxsY^jnfvd1O4LJbRhRA1gBX{(YegGBt{ zSAiT^^*VASb*u1-c`kA!k$=Tp_Pfaub3sXttkQDCIsXRb%~*vT$stDu44=Iho4b@J zfj6Pe7ecvmiPkyC%8|lZxJD({4yJr7OJC%*rswSA@Nugj$Hu8s%EwP~TXSVO z?bqcR1NwM;$q0JKUz<3qdy0+)S;-sLhLK zg7TS*xt;P^jQKa52#;M&JDQc z`nk~Q*w^l-ekL9I(dvEP{G7x@d6u12o_OeJ_bywxcW+kirtQkzyi@d6oHY}R#;)$j zX}{NN1DE7Ofdf5J#Fpf}mZuo^9&kJY4j#oesEsvQth<$8|`--KS@ zlnw5kQk(%@R@mV}w^{Z@d|b`P|3*7?V$;yER*1VS^<7HrF-4o9^=8=T09Esq&zpUv zE>}xF9q6{5=(G14=ur5=R?WUaoB4@Q@12S4J*sWVRc43C=4IH$#0L6!&$5-%$GaQl z-A8^R?H(~rrysheO~!TX7-P%4=KCDp89~4Ld24zw-y>g~U_CD!y&j2`2J(Qh*@tFN z#(U&zvQ}v;*~gjhjZV;S$?eiFSl6EOvVqmE9N6^{GUygOP zJghQ@N2!;RxK_c)+(x`3+QR>p;q0-Dq0P!} z+!uA#cHT+VIl}wcO1|j-K4?a1o%%H#Y?y0kSbCw~!DUMJh8TU+8|-k<7)9)?{vDE%XWen5D{Je}?jJyH*YLZBMz>sJJb=7y}us>syN85&2{1jDS81 zzd(;ruN&CZQfDc?0BhF1AZs4?M|G^YZ)za7QeP6g0vR2~2TIQi!v9t48|sCJ_dir4 z>lC{1XMpDy*4qL{=J0wu^WCVONq~d)rO5Wc-_*WG8D8`}@K*5DUJY{-`v?rL2eagC zWS+6-*1zaS`TR+gTzDz&y{t7@OZK|zwUnN#9BT<||BfR1XP4^U*#Zsjq?Qt2x10aR zV&(|`1pL(QaJ~uO44-8iK0*;+0Uu`J-iU9>|DPBChP;ie&oGIP8XMj#@;}=MuEjsn zwr+VoYOmdJPT$HQ4<%0Dw|;_o=lyQ;swq|T+QHt8*edJvUyCkiQptJy;Mv{CzGqU& zLz~fw?WNjXL!JxGirl?C3;mV(uUOIt^8-IC*6G+6$^MZG(E9FO%vX-#fj?_ue|?--!LNW{UE^7{dps3H3^Ls#8N-zdV92)fYIQy)Q+F@WEW|Zfvv?#FyUgN11zV zEp~8S)LDxyJ>yT5Gy8KYS^GdLS^KfTmQJk2mi`#F^y8r|%{qjZ^>|sytGt%UCL+%I zx1ozZGmcC2V5niNy>+Pw*D_3GJ`bptD+uacAuNI-$2ZZ$Y|_oVJEp#?!XA zo~Q5vK6dOgAG zLjJd$XPFW|YVEZ=Vsbil&;30P)QQX=v>d=<^|BHaT!z zB+g<)y$%C?_oVH0q=`K}NzPvK1DkBIVcpJ$p!ps6XzQTq95lVI&P+9L0e-6j{%44h z&H_Ica5F}pIM#aN2ZO|3PbUVunpo_mrn_jEb+wbH0jI5_QDg<{8>MD*ebn4+8Q$g| z!@MVNc=wDN=Dq0ddwZ03cOF}76gc?n+Ks;32fZFb-&x>i2DbM~a5l{Ib-*}ayDd^{ zUQD1Lk%#5|I@xO}PBq(dQ$1v>Ip3HHe(KFG@+)2GdSqTbvTq8woB|%Fn5P){v&A~c zFd72i0l7#`TrfU)nATzqyg{uTvW#3P&&&MYjo-q4y(RRWx&wXHpZ2Y-66>wq@QmoI z)QRB!e>rCCoa!-EQ!uyn&R}l)+)!7(mwjUHZFRxiS%6 zt?ja%XE^zgmbG1xIs{I%O)P$$gMRNm9ec&f{|z#;r2iTmYzrr*)P}9XODS#Z@}BlN zoBvh&WPfRH&a08z43&9pXT;ka_-1YkHeIhRwqfAA4)$n%68|vdlLGr#*7MK|u>@#j zFb_RIAFa?w+c36+l0H>&Jh3axc|F*Q(9=EqUucW>yiQwrt%0xVn5RNxt0In>Vys<^ zg>38?fcBnejqnEXO>Ijqng+kDfbWX%oB_YB!ZzbGsO1+s47k(LKvpQJ$2QA4Y}T;U zmK__v)UrZ-lfDKy_b7b~rzwaTIK4e~(i%+-MK_5r7RDWJjT{qq2;|MzMOH$amRR5a+DD(&yx>~A@C#~$kVzTgjj(Xz^I8$eHQ zBQ9Nx2K3%@Q9$p@J{-{dSsxAfA{Pzm{aMD*zC+mm{Uy6M%dBg`6rjfzu z`0&i5mh;qnIQ>15fX~kOa|fOgy7BG1!dy*u3hP#7x@jD4@Vf9D?~CFyFNZc)80Mhp zvmEe%KP9|Y=*g^2M7;ZWetQ@Dk)Yo|xsT|-pkHcC-zv#?|UYI zL%mQ1M+4_Yy5ismIOabV#6HCTs)8f+r`QKkXVwS9T*G4@93l7Mul)>s#5(P(v|sD= zVWY&#FkK__WTvk)$)COE#N&~%S&3Ig$Ch%i5>Jsn&;oG}_M&AI`}GiO+#xci>{}w= zBclIIY#-#if_|$iOw!4nAfc=lIe84gY|v65mW3_ryO{)cFr}%Qa(6XI6@&qbOBPSrJO z#F(n#Onq4VAU}^UfP4%3X7}hEj`$@!*FK0ILnTF~1^vOtc>jNu{%-5r4djeXUp@awEp^l2QQc7;!loh+iC13 z$z=q#S93<}HII0U@D*|Sw!Q6UY~zirlsv$tIURfP zgol^>d;}YtIQ8F-KQsR;=+~Y_7gDsO^9%=qXQRD3mZP6}`-6A)eSZAiCHsPY`RlM* z!gtMQgJ%}+63Yq3`ziRGkPpoH{mR>fy)geQ_G~VG410+$7ubQa=h&~Bp9@c9YLF9~ z(4C`kEgyU>52O#gp!;MWbK)-@@zH|7?ynYFigM1KdG-2v5NrZJVU6@EvpXv`O03KboUUCuvK4+Z;V_lD6!_ z=IAApv=v6o(Q77YQ`^na-bvb051FI4PSTeBra8K4lD5KDbM&D}+SE79(H)btrM_;C zJ~>HS_I`8p*-6?8_nD(FOwy+AHAka{+kvh=W{*;v*}qBJvYXhyN!ki`vwxGcsR8zH zlD5>H?B679*}r4|CTS~tmHnHfP2JA^P12V7GW$14TlO~gZ<4mct?b_;%YKRdo20GqMfPu!Hg#jAEXke7q` zu9}dSgZZwQke7q`{(3@Q4(9u-33)k~@1qm)axmZJ6Y_E}-(?f>axmW|6Y_E}-^CO1 zaxmXT6Y_E}--jpUFh?I3ZmWAt+{-`SaLoIJu?mH(AbD}1a} z$;ZN$#P331_hCN-eI;&>f7cT;d*U(e--*r;86y28RuHUjiQBdgdp7iG$NliX58uZ} zTl1n5UlYSed$Dr8#PrG0;v8_E=y-f^WZR^EL|L|Vyn&sfVJ>t_&i@!47_8?EbFg=k zw$y3n-~_r_znA@EVj0KE>|nlAnQxLd^+(J%Nn7d^=9{D~yPy)6Z$=N4YE4Q$mq}ek z#*WtcQO<79@1gcE6_xm)-`hxiOK&2%_B1n@Sk7K0!g%93!~xp_8hEevkN(PRKPQYg zCd%^keP+5WiUuU`oqmyE{cutG1MJU%_FkVm(m0vx1TPbJ%I`z8F8ghEQ0UX4!@neC5 zSh~4|+??e1Eb$8^9zvcez}@Uj9eJ`}Y)K?*FExhNZb`x0)Vw8L&DaaXAGR}%E#zn4 z%AILe)WMGvKUDmOA!-Gw3m|7mY=S(W_z&V&Y9BIKce5V*x%;BYM2{gdBN>;meWxfYy}UtC2!z}2-v zeCT)8o-r!R59M2QWGKghQBc?qN z);w`Gb#RAiZjMI1%}eDx7IAOl^Whm|=H=ZToOy|ww38F0y^}n$*Jl~mL28VC;!$9HLYvEIKbNpOYtJlNa-8Q`u#a2GiScc*HdwUqooMCKlAO1wD1yw&t~ z?7UUEH#r=C93wMv7ts5${bC@68FWk6tghhIvb8 zu8&$T??-4So|`6~n-jjECIftRfv<%cU&MQvrz0JuUHFRJc944ppEaRe9gz4`C7nsG zP1BjiRpD}UYMqJ9@Y>RK-pl*B>^#WJNy!-N62M4^|qsp<%;N`T=8@w(rw+xWSd|cm8U2JMeZ3oC_-mK zA4l;rxo7THg^y_O+!fWl+-2|%e~b8Q0j`jC-44EY8rTITUS@4oynNJpz;lrIE@B_; zlALnYdIZnR4gP7Tp3!ZE9@{E=_c??rdfGWDYdHo+^e^olw0G(?U<34G1MHyIBTDVhKoza>J~l)zHpC8WgeW?J z_6k}L*W*J^?6K%oWJbt~QXAE4cy~iD_eR0zQt%3Hv9U(v z&WF5p(0PBq^55TYB)>4C{5k!G^EBU|=KD*0{|etf$XWgmUT-8n`}fK}k>+b(HMH|o65QKI>R|(4d?vl8~)SRtK{E&OC>Y! zH=G}H|Gm%=FZ%|M zm1{b%XW=zh*Yga7wY@!8NNgm$gXXW{S7@YYnAim#I^Ud^i+J;j%ETV_I@5;Nnlrk` z-g4Q9m+$O;@YO3uo_n^_F^6vVz07Bv`b9_lo36Os?O27}y;^J@3mtEDZ~S3PsiqP; z8=lxp{qcWH!_F4lgLoH`y)4wG`;U{yDvEOwvkW%`V-wB zc`(lymY+XFjq>&jsnOmiG)>K4$OGIjG-LnezIDONPT!+rzWw)~b*#bLg18U;sJ(DI z9(q$U6g?g3*1n_ljS*}Pzt4WK`vPo_SnTh^nzqP>g4iB~d+}3{U6On35&2%O7iwOj z&kB85cueAubON4Ed<-QAD2{+3+jdmMYuyZpYsQ#ebJaa%@_N5kN0A9&gwywm=L zf9O7=>B5oykNj76|Buh{^ZN!J`}}|Q`>y4k3$C2#of1rLTaNM8A(!Toa|btP+tg{= z`Yv^oGb!Y+k+qyh>7({*kmokGt;7aX+UI?zwEMsx$S|q%%Hn%Pqa|Cd6h{d9XU`m) zWxeXQw&9EGzPu-K2K;@_`3p{vd&it%5nV#=lDl;7l)I;o@%2U4c^$~RuLNgP9MOrF zv>Q$w+e-A)84n}-IG-}dwv+b5$Th|J0rK$|Rh~;J;M0n{7n;}}=uLc9v0cSJbci?5 zhHabQE>&n!} z>hzhEpFdRR_k;J+8rL_4XKz@q)sPb0Wj=C`{2x1D1pF&<`zdOrM|j5B6@5;}qW<9k z-wz!bvJR$1z9qL4yAqtt1}A;%HBOS(A4+8|`fkNpoh-FE5(C+fejZ?twjl>%=rO@Z z5nSX9pYNevAa@2b9(3{s=Urspz&EhJ8{njHp1kA9IUVgYl%A*F4_<=$(0&V=A1K)( zPlWvac%X-K#3g{^B8}faF7sBvdu4j@G|#uF%&ff5Oy-XQYWN7q|8kzUX-JD%|YjW9PHPZaxm;Ct7~gD56vItEU8tF9f}+k*&ph> zJ=9YtMCXWX6kZEt|7raG#q01Kb*|$)ms8O-12DSEDzMOV6o&p&Ie%hn> zFH0pZ%Dap~O=4N+TZKw|J)-N{G``U7=m?WqTd!lOj(@m!Z6XGV@3U!#%6xhML>P?*e@Zi{leU6A;a}vYuku^24~vErY!3@gX@0-1 ztG$~3`Zs`trW~thi{uwFw_4~MY{gFeGph&veRI^umI&|M`N!`4^tG35qFz_qGnqNV zbw0XD{Ed-IAIx{-pN!zAbkBU>-;UJaw_Jz+GWLCR^WbfMe)zLa41c8mf|uQ{&DcBG zfQztuS`KSlR$%b0nfsjnzrWD$|J7orW{A6?w&P>%Cq{M{Kg_m7M!2mu^sxus&1WZn zU3Qc;Mp=*5oD?5p$p;AGsF4OZ=~9{4iP9^*_Gf&kx>)|MgjZ!)6R0;N@{UVi)$?UNwUM7R(9%wlO#S z@8p~JIX3I-dvP)Nu#gX-4~s9W&kGx&pH+tMsSv*ZJPN*lVZFZ~Zp9sUIqte!$Nfoj zx!Z2BvJ0u>*4=Hjn~|F;?q;<=9UX=lpMb zEAfyS+^e`pB_%d;ejjlUY+dfB7&;`emxsB7aWnqFK~u*}{tExXdaL28QI)yw$M_lK zHg~>+?OEd0>~+rQ8opn}nft+|#J7~(YZ2U2wEP;{IYQ3$CcSHT}5YjJcHTcj2?n${P%SC3#rx1M&~QRk?{(wHp(~gj>5Uv9Wd_ z;no<5jr_TBKKaXB&zUjk3%oO)D&enBo`o@xPfIuib5Wo{XLo7aO)v22F&mbEMMtkacu)~I2gz1#54-e-7c9x}`& zdBa<>-Z0-iXn5})Hq7@xNAFo_n9DC^&sI}!L452s+i;qR$<4f84PDB88J9i9zP-pj zdzN9IGs7^?ZRak{)4Au9yFPEZ&hUMY7+t+VT+PsTYaWj%crPk+gr(Cm`k z%6#`e<-Pk5@v?Yu*C(+y=fqmW|0=j;jN~up8_AC(jGOY9ZB`@tUWIaQy zC%OMc;)@?9t~ixBuK?Ch6Q|ov9tWP+d97*iCA``8JiNQNf_DQsAowoDvdng9Z;sXW zMzR1oP=_3-Lk`p-2ZFQ8?LC{21)Q0Gp7WXpzr8bU3Nd)%*W^tH$(wE_Z@QVhDY;|b zC3asVhEJ|#kX*~)T4M0zO*fNoB6p0uBIZVW>n^#c7vJR^p)YI0GjfM_>Rno&w&(P3 z1bE0fb6&d6o0qFIfye7Krg*Js&hkT7Wq)xO@+W7T9Yve|G1E1)d{}M%yhYrJZ%Q?xSZ59l;d$hKh@#26dkiI z=XmH1bH3pqE2f)W+=JSco^CEMrjtvV<`_n!*t{Y~T#2`LuCk7iCjo!HqbyH??|(Xh zJQ>z_9OqBD2RSl!-RREHCi*AGf_?%!@4nDJ+#B9Eawz=%)A0KX!S}Mh91Hd3vw^bN)%};)I`!ZA*$AKhP4)Yo zsi&4=BL@Q8Vb6i?574KkX5R>({`J@Y%;C(D+j%wi+A7gu*xy^BhrMAAXcuwpqT%Et zp&gg9zHW_#9y%*SX*c03@pl!m!PZ&#V)}Ss5 z*&O&NVa#*og}LsIzrA&2&#Z0T^FE0!Hu$h(-}WKD@3OT{tb5{^=kA;C>25mMJz~G` z@7>+kK1R&59ed~h^85B5aALo?W1^U+NsMs9d!n?>x#TS+J$=kQQbGF}Z_s}28;pOA z$r)vxvunCcWgaJ{*L1$hoWngrr`2}RqQe+Uh9dd!#7F9Vg+L1v^kwLx4pdHwrv{&SNOSZn*LA&Io zsC%Iu8G(%IlzcJcw=;eR<9F!s$x({@rM*S$q%=A@O}-ZWsk9!R?qcJH_WUO9bPMH2 zO5%0pd@1YFdC^S5u6Nb28nQP-r>CloU)ug!=A!-e8+qm${PEq1U8OeO#Pdt`*KOpP zAG=w(^8Mq76GQf0Dd#t5@curPwD+f+Yj+;uUaG0xF$4N+ZWzk%Bae@M?B9t!Jn~xR z;=?uW-Q4Xa_q%nCyvA6_Wu9Ml*mgJb>|Xx1@b>_Jts}2-pWAD02mOAtO!)`Mh1rKw z<2*<{%C=u4UlAGm_@l21Pxyy9TfLn)c6SpwtNr9) z?Rvi-`-%9S2k$xj-?wLSSL00N>0#E?t>azEw-nUSi^z-qX7C+hCYyT+oA7(zA@tYX)eDDser7?d#`l`RWPv?BR z_89M;MSs~7*4o!cUvinNmkExVq+QzlzGXZ=OJeCWWG+A7q;aG1t?|%O!h-@2{G4{wAnz1VM*+b{45PuRxB{t|qBYV1bqxzZXY!oeHCr0Fl;r(p`#yi9Q?@Xx6O z{htlFXO8%}+?CC{40LDuC37w^Gmxe4LQd+lgJLJ(Q=%VY$oGLTevqGqonZLpMWIcQ zKQYwPvqL?7LSPeoYBu_sbzOuVfL+jvUC=hbSl9q5u}cb9A)CwhmosNM<`l#MdyqA6 zkZWiR<90t3JGRjCx^cU}pX<}P27T8=kZS;j2sWU$MS>WL*IW5a=pwYcjz52*?XJT9 zV{*N&#Av)P$e5Mu#g|7`v)0Po(L1*Xa-{-3{hs8DZX1nO<%@##pDybkyIyid6XaT2 zw4S{7_p>(j;{Yf5U-)4j`snZ2v6`ne%;ZZ(f;yjr)!#>dE#HH-{BOqp-}8#@S8;|_ zXoA>87`s%fM91qmqtfeY5L#j%C#0uR3{zr361NEApM}40Z0yFoNWXG^_&FR>+JBxZrT*!9>cbVy1C{$KV&>R`gyC})&8&nkCcn)A39 zW8P!vm^g8o<;2OcH(E#GjotVc`>>%8VIx@B2izC5Xgzb~BfvCC?posTDeeW={B%7u zrS0evoPGs-0sgX;@V$rFc?e(rh`AY?Z8J98J=kRT?BLEBY_NNm9s?h-d1CBKSxfIx zu(FPpQT)H%Rqz5+XqW4pL1cpxSk)KsJs774n{^bM13RI94|zp9!Z~?hgg=OdHJidO zkBpJ`#h#=;e{#=B@O+7!an|eAbfL#BObz}oG?A_L3&Or)BL;D;{KM2bY?bfa!?QKa zx!$p1tCl67llcXXFb?=|K;KrFLtYjax)1y-bw6+rcj5PC+j7LZ)-^yM)2KP+_i58p zsX3jB&&XYQS94chZfdX((4E+>`rMAX+@yZRn;+$TgrX)Q!5vS%Vg85u0{dgekcDlM zD7@m-zH%g)ALRbB(IefzXeAEDS%K3}Cq_gra`ov((pqUI^Y`Ny6Q^r>IN>B-20u&1 z&wCZR$6ii_a~3{~4_%XKyl=W=#&#`EE=5U(HLU726=TfiS`5oa1+8Jm;%Ri@!>W+)$sN%D@4rKWx@ zI1${K$ThERDeLVqhFGuUUWX3JdWTaoE}xO1-c7&~%qu({?i=@1DD18_3%QT}p8=2Q zT95{ly@JOZ@cSF^?Wf}RPsQ(_ir+sKzrWt(omX)P@jEAS zho2D-WyrtCnF{a)Jm5Q^_xCW?A!vj;^&Iu;azEKz?h;%aheqPiNE{mB_ff7Uu9S-l z-+Ei%3+5Ag$=vjRPE8uw+dpYZ8Ca zMFu6$Xb;!a!Tye>gl74Sa8`zOkk>2oO*ScGn7k)=239?9FlVX;nVDdZ`K{D+f;~>K z$8q*J&K`5Oyb))QxjQmf!@ksx?{R**&t3Q~^~Q|JUgNj6F17;S)rhk0kSDSa3CwQG zX~Z`+N&V1a_WUKr`W1Nzas)Zzc?8hpwO@P8nFsLDz7)C0K8s)6 z0gY9hdB86wrnQuu0_RjZc1R5ecT#d@qN|voMvt6>)cq|rX*X#n=S+KewpewJ_22Mg{~tUWW3FcxB1xdXs3P)c&O>5{aAPg zgMBT>0ghhJ(Q$;M@By5Xm#Ky`T0}oo!kM}RSq9#Uk<9GjD6v0qO#CnS-5mZ;46s3- z=lFllt># zeDBozyH|eqgCm3a+1+~{`|FX8Z=|~q6iyg9@V)Nt51iTMSS$a{&#!;gu{%EP_npxX z3{~ejy4Rn4zHg0u-swB=0yUKX=~(L@tIT=1~lC@c69&yr^;uQF93Vb&O zzMBHy$=!tY!ee|+cqfV5mWGd3U~8<>b%Jt_)ks`rGuQqbXQh_w+9J8L#Q91GGQcL6 zXKDE(^@4IYX&~#fzZ&XoLuPy|?cQ}eKKK^i{j}y$VA8fBFjd{uZAlp~bsG|0VUMU@v-RcAp1dMVB^9yJHidv~&19;3bGp{y6Bjer9<7rJ_y! zD9mfWRDuy0N_Cx8cLE|yEMy6?C{65qg$1sT{oSB=4Yif{!rZ^$ti?V>=9JEu20AtS z7O@SG3Ghn~cBg#iv47-q6k3!|i!&;^ow%NEm)r;ZFiOqxdHe?3d^MC`&wX9(a*jx4 z{yEVlHdOidh~$paJoz&%`&0Lkv*?ujRo#{qQcF+1!XU(8+hYLRnwCHnZ`(Au^9w$b;G$XH`@ro4>)5m+K(e>%jf^gT$@U;9()ugwL> z1AdPM+5SrA#<=arPt|jA#~I_VOlJ<>7v)|so~0xHO2$4vVfg2-<$l}m9ibf@ajr-8 z7#r1Y;)UvO=nqH+C9 zU~lEyg1ADT8{{X>n&(?LgRkc!;XT^B0{o%BD)uiNZ-wA1z~P<$xeJUmAiDQd56!sR#-0i9_%vsE(hPOgYO35yKUrw--y== z=osi;^HdKu#kPRgG*69^Ba!d$8g;<%BC>BA`X-MYlvSui@`%eXc%I;x)g_Yu`SK*HU*3t%cXR;I%JDIq#a{Toih*0>7G{ z0{(crxxg@yp(g#9M{ug`y;T8E7Rx+2cE#|^a(3!io=j~Bcyh{XGNH>7HRn9_Y;KAW(l7O+##PG7Ctk~*XOg;*zcXs^nR+pfX{6B%!bcw z=-Eb>T4on~*9G4#Ft{(d7&RB>qTa%E)I7zAdZ!fS9{rfswUzr;#cSD<^}e0Lz8yUI z4R~#v8St9=s?dQ$jH;3r0$$6`5}bv2oS4@R3SFc=2W;A3_xs@s^lPX;=ZE~=DfiB6 z-IVm;HqJd-_~KJ3a#T^w1g9kn|ls zGIV&eO4@r;L-uGY^BOt-zTGMG0D2pF1fG08`K~{c7O`6FaVLfkV(*U(#rEN6?vEt% zqbk{VNDcL_SAp)2_VbSEtU;HpiK2hey@{Tv+a)%H*wtyqFWCdBUb+87->=Xc$knmN z&D{65Uh8U!E6H69V>fG`J+vXRw}XcWv=D(7%JrDgLgjs-Rk0t@{T?_8_NeeH@h8NO z9?CzN%Dg;iOB^TJw<$H$w=j$b01l$NNJ$o%$0wk8$)ELZc?~F^uudDbWUUc09($ z8jkzSNWe4mkNeDs?w>mO|M;1a-Fpn7v&`2l+i9Aw%I8I{c+?*M9g}QuUgWk8^zi_? zSnj;XA0-CwSUKn^1%0MV_j11ZvmyaME-~AS(6`vEV#5oMsxvG10bbC*&5~){gM1gd zpf*9*j1=DP;(M3&RA?fQIT9b)bj)*~ng-n-)?Kp4_|@y85lD4{Li4PbTCOzr5$DWMkNq*eHP6%L$RP44Z#^EozwC4$`9%E*=Piq3x05gBOo_y7 zx{8d+xVlDVK*rQO8LTFT`D)K9;mYjD;X@R$Vc|LKSGTPQ|Lua$4C4KP?jMOy z<1S^n8#s;3$-!4eEh|cA;=Pt)nP;$dqS!hn`c2!HVz00^OYko|$=yOV&{f36=NXFf z8&w^0H&|(|?CP=l(_ivGI83YyU+JnIV!vth*!q<4aOUG3+*6WM#MIT;MLoZDu03RC zzQ!FLD=$U9*)`6kR-KHyF*~Y%S1WT{0w1phn8(K$yQ<^2%x^gtP-D>4V`S#UY-i=D z^7m{;mg+I;sX3?##=-Z?$yj$D@>g0$@~!M!{H@jFeX8R(;v*x|pdVz4_C>J~h;M{4 z@4Lb8eiXr52>Zq7K2IL^1?K|dr8D-8&wY7psxgsv0`4rTE&qn3=r5<1Kk*p?xw*M?$42IJZ*%Y`I-LA+Wc1co#COa5e6UN#(z?=` zVK|>-%o7(PlR0Pk3x4ZpZH&B0ZTU=%){lC8{L5hcyEvoPq3`ghty7uLyq&uOREvx) z=QuMTd;7^!2dw@7K5(veT=x4?XN>Nup}zQt)C)1DDU=P_3 zr2IpNrG8<$)S_e#@8uRI^`UTLf>@9K57I?S~9&Srd`1`i_F9!aL*s#%NN9X!(d^7KeJP2Y1qbnpX;_9HDCyaq=9@2H+Dk}85;VSL_ zoJGBT`FDAlJ7^2`|8GQ=`xf^s9vUSt*q-(`a3}a{#BFYgM#YaAzn?*V-!aA6+jdj# zRZI47O8M9R#&oWYkr!0>Hjk;yHTRV661axgRQP*i-0c9(mCj`|M%20B^6_zn9>v#@ zIIPG58@)*UF_0(OF7b1G+Wdb0WE}a6mF3OD@}2!Qpb-NaDaU5Pk=C{0-o7Kyc{~3! z+=sKm`qq+;-8LCc9blUnui3@eQPEP|vKp`IFQv|2;#~p!*meQFXG@;XM9^BZdQcK1ME`#EC} z!`H-r9!0O&)VQ_mgD2^ew{%^IiS6NG8%bVYd{7yGXq0yJpMM+miKlPnye+kKEyPTD zul!p%GxExhDD^k&NkAW~FARD3FMP?#YrCtkjkB51!E_<@-}nPX$i zG3&jiV!d})k8#G;!5G=9G4x#6rc(bH%BK$p{R)9CX~oJg=^DxAjyLRAo;Rom|4=ZV z*!%(PKJz(tO?li&X}=e^M3zVl#cDBxrZa1|V?$D#S-**OJi|S)n`(kRw^lp$GvZrB z!tY8o<-e9J7eVGT}=;a5$6G-A$~6oV7!Pmi(KMQ;xXiF1kZ2G-_|F6>zUB^ zR{!NNhsd_jPWxE^&%RI5#|q`fPo>_(8_aKYn%Y@MO4s2!BTb6m9Y|46PVL4${C^mm z6#jZ{5MEOS;hD^fqe{*lx^3IHYWlg9Jd?HCW9-^s?7~mLCubS)r`y)yQ)BP9EVjH3 z%P{8=*PoX+%+68jjPNO3_|47ZTZ}66K}&fLV*7uC@0&*D_W%s@KKkF6C-*oS*0`L1 zDYe+>`@QJ<=kWs!L-6LdOe03U3Ye}&w+=wZ2YFT`x3kN1+xD8kLcG{O7ZacBnv3s& z|G{tZA@`#tnh-p5E{2+>B0h31YR*q%?;B-bIl$p4H9}iU{=*L>X6VF9bi4Vlf<3$n zTE-`+BmR}SXgE^dkI$6$WAoOM91G^D+>`7hn$Id~vGniRwe@fHV=29c%(IWe6a3$z zc4PG><#&r+xjDt%14ojFA63a{AM}7dby+@Ip8KlNXg~{_w`No{qT%lYC(xd*$(B20 zgSdQas8_*nt{gi(7EbkWcoyKNBHycii`o=h%zQ!CF>)E_JNoReN?udv66KtLE54}r z50mk-E4sW5`TP6&jp-Nmg}*Uf;LI)ijejJzeARDFYdb&tk3K$y*q-Lmzcqc)|4)Bw zTGK=Unp$&QzcpRPugEnmizNqGif?7_@sXLqZ%#k`lG%}0nTxmU-$={6id^YH_uJc* zX^W0I_)2Ea&a&PP=x^m$yP+q3$M+5&_782`?vgzrx}@qi)&n|QCg-R|;AhT`-x<)X zHzG7^ZtM{{6&kOKt%=~?6IlYAm$NOBl~}_-tW6@*U;#0HPUp+C^>=u zPA=P{&ogH3ko$;;lW*=-BYXP))9>4UvF^9$Z_cJ}|B7$H&%g1fbk-!JhHw*@&% z>{!Q@bzUDBiTS(SXBx1ntPXejFZ^JErlUhTeXc^6MH@_dm4oo3VAL z`BT#D!5Zv`gzl^P{EHU42ADe+<8vBOJr{EZv}A7~UWKk%CujW7RRTXTV1XY!b0Dj} ziSF-myCi0@3coc+PM&tFh+R2AtSZNOM1ymEvi^1Gt8M5j#*&ybYB3li^`lG!@q^kE zHQYYGeM`;P3qn(lbtIurWpeyaaJN1pndv(0;<3G2394)o^R zBNsdUXI&A%y^V8^dx3cu`79$EtZC;qnfrjM0j~x%NLHKB7d8!Xlu_jP-OpS$@pNF+=QM#C9BcfvXn*%R;AeJeUrhGOBPM9hD{>xW6g;yh zZM@sDHxlwOcSW>-Cv0x1ZD=RQEOs8c7CI~0bk~bb7us*PKyM}7aBoCN$LQ12oUWz; z=FqsT+W%X?pWNMC6X>#Kr8^e29%0^6{Ob&pxjkSB_xxkf05xCf@OyS!H~i#SJwJBB z`2|Sad%bkmH3vY@&J4yRzr8YQ> zsr+vHjV=#lur(0!&As>!MtE=7`+~NfTS6SI3uqvAyKh|uUy)bU@rdlVMD}PIn45gTjTE)zA<*oqpxK?wmp&A|7e}W zDxJ z4oPgJ%uVe&k2{2KSH^7+*E_d_TaO&4S&`QVKc?`>WY0tXd{o=w)IvI9_bZ)i+Ei|n z8cAv>#@p1u(KeF%X7i6)PO0Q^=N|*PHvjjXfBb*n-Gzmpq2G=_AF1u*WrYnt)V9lV z^gnfE=;W&B*|Rb?T8+V;=AhkmYN&n~9gUCnf3x@Q;c=Da!uMLU4l_A4DP3t=+FC*< zNe{3Q9ZE!fbt*|pLERo`LEzgWt1Sp@HkU#{K^!`n^eCW1@SkL6z3Zw9<0H)-Cz3pKe9GPbV?zLp7jWd{emfdT4({0rj@7_qe~X>+G$UL3<-`21GhV?OKd5ELmLE=AKZ^4Xm@&AV*#ccz_}c`D ziJHIA)~j!k)AQeEJ~i}PYExC%rn4J)Z*7Afd|xKMM(IQRe11Q_)1sEl1Dz+|m-dOF zebwmR+WneyU%sDm<+Hrx(R^Rzp%(P_ind<$887HF^N}Ha4)XsU0ssFm@Nxu=#}AGC zE%MUmk>kGteMKI}?hg-8aS+B#3z=W!I`Jvt!_c^Uvbsq#sHZMDB5uVK$g=f1xlv;0 zBd?>0oGJdF*#wP64yH}aK5vfX1i6blX1L2|lD8l{?a8?KdW}x(eAEdSUt2T*EK}pj zg`GJNopp|$w${a?8#W7`Rw_M_oGBSca!z8_6LGhA@%Ut;O`h;Bbetw~X0T_^x(S$J zUv94S``kcHcj8%v-npUM$ZIjRbkS{d($<-}n$z{OPZu7WUa^AlQaqatuf^Bs^Mf~J zjZ(wh9Xor1v${xq>$Vq7awp!VJH`01@4t>X%Y|UcuU#V`_fE z95a8CIi^!j#G|$M>eN+1Pou4ZQEHB37jwr7_jwn{Y3pjX3TJu4cbCa}W0(yj1vJ-G`)PChfcU4E}5AyIg#2{BFM6&l!7Pamy;c zP;3X{`<6SJO8L!?qH)Of=xUs+6td3`G~+WJ;D6N|u@!h@)+yV9cXT{>`V-DdA|kSn z=su3cIiB@{P@N_A>C_sY1u|R1?~tR=8`$oq0*mU(ppGC%g8GPf5wu*tm1=1D^I7zsto_x*8Pl$b2{6(IvYjt5| z6Z)y}UjN%#;Pw1T*17GY1>c71wzF5^xtFwISMrw4{VylNxo1DTh%Vz^(>unf8jxV_*!%gSNGRuh?s&)!<33 zj!c5iN9^e!j>JD-2vfmr8E^D`-A3FV?`u*%tkim!jrZrWY_B6Y%6bRqp);qG%>#JM z61tGX)yxHj^YG!a1RTqpWG+V3Z_|jK>SVCnR@H{D*=z2^4wpDdKgp?nKdtP+$;LW= zN|JN0a60AVS#Vw^`SwXU!$a%Isp0u^1ilf>>2cwg3O~XE zCpp`~KXUs8d}?3eY_o6pCI{gZKUd%c{mP$fv5`xzTQmgy*aiJarM?mPy?q;^+7szt z;)EHinmtiH9eafS433leAaoy^G+2W+M@Ni?Irylpz{a`jfY><27w6O3 zL{YXkB=j|T0Wk*6Gy0^Kle_dW z(^<~{_ztN(rDexOL_dRf?G5>{FW3j-!cPGIb< z1TW5)9O-;~p=0XAl7K(K-nMn22SK-dTC;3TaF$jSX0I1%CjO$6J#FugPTNVH ztP0?^uRl8DV)BRf^<%r@*^yrEN$QKvXz%47r9Q`Q>h)=Uyn=NZtV?1^O`((gKB=C< z+zf%W_*^`zz0atT7?(!uRLv@1-RNvrIjYe!_pzQ0z1+RSoR0Lz8qU*mF@5PJYk&*! zP;t@a0y#O99A;9+Y1i|=Fu^1-HhQL)L-Zr`AEvv#iaZi&j>+4(6n@HzVS} z{9KdsONQ8!RsM-l9PFX0}#}|-|I{*x)OTK9{Th_Ym0`8o?_nAD_JOY zh~73HK6wVbj{AK%lPWIWm-`$3LFfW`zQH){LJNDNGt6F}?=>!}Q@*`rXL|x$+f@9> z&+FChAJk(zXDB^Z_AjIGN@(S~y3>_&RuY}|-4ggV^-X?K#F-l-G#(zNWIS?-0@-f& z5%{Bu+4A{C^IOE2=mqlCJKhD!`irp-6dV6QeUE?mMG;F2YVWIYq6_czvrW(>&C)+;?9~{>}!q0BDTiUD}FDu)O2i-58J!=tqU*p ztfnsie2C3m*=H{kdM13;z%FD^*C{tfRASjGGwjmMV#86LUsu+g%Dvt?BpKb*&WGokbt^5MsP2fz7E$D-3r z?z8?5_}>tYRyQ5v?*X@X4ff?R@bu3hQ-QCu+PjVE-|0_I|8>7HW6VHu#%JKM8>sDI z0*9t9&u;HlbVKnp?MSkQK3h9D6WGM~jlaLb`_5Y+*N(xqn>Zy|{cGfiG0;`M z1y%+0iX4*mZt75R4&;vH1i2b!5A~&}CDYy=+-dbi)uwEXk!&fZE(Z0FTUW9k<~pst zJ6gT7o9Dovy2q_6$!Gbctm8QAI37K7Cvg`0j?-s1eRd~nn`nRUacJU+=nU?ro%JhV z_MhzW2H;|z;Jg#l(sUwO+kPTi^*DM0ZK`QgD|g&}XCOOe&3|K;IT)RB(+T$LxWEuw z7;`mG6vD;{YknOS1*6O>jDKPXj4G^jRx}wwT`f3 z$L;*{wZs?j+_S*vNn5ae)*pFqyf%JcA+H6_wsZ5*a@AkO7W2LJmH1v^Up^g-e^>Yk zbT)U74`&xg_~%;o%}m$;p; z+2pujAF?7zY!n`NE4d*?D`T}ZLc581(TFP+eO4o`5E>L+haU0>KO6W#zLPro(M|k3 zL2eMSm{H_4sb`;)ff!rGzdN$u;~otSe;)Wldjeb77ybVmun%VfAAiGu$QsanWMbh5 z8<0&mBOA9S`9%FYtto2(~j=#18rD9soYTc@SSNZ>=XZ-~G-%rw=yR;Z*H?|m_J;^SX znn@}yx|F}ElN8-R-pV-QhdPRgA38J;ee7xBKg8b6gVz94wdO=Sw6hsakqPEEMaqP&?sy?F4%yX$d1n<$SLph&E4wu@%zvyGFPf`o|$=v#~ zA?t8}2Ubwqp!i+ui~f4*hR|#E3|k3n&)#btf}j0O_E6^SSx5SOn8m+hG#u#@n{d{& z_L94JB&hv8>+SHT(6^VPA>bZ&v4ca$TeN8D=3bHY#fIqY0uQLs@9bLS`$WmRK%QPFIF^|kD>{SPjbGJc zsZGcjv-D`~Ce7{rm@a#5%u0=MmUP3P!Pm;I^eMa*-F{Zb7^4GO6FnO|HUm5kMc37H zKjg*W{Gd%rXlo&kC1=gSr|J9Ea`>(s9DbzOxsnv=&P z(F@eG%qif{arzs|cV*9Knf+?di#J2B-(k;-H}tPp?cT$lt8bwFCDQ+U-1GdmJNwtG z@8iH2+mls45X8{GC@_bn=jDRH){vJ8RNUW;)7iHV;lI|=MI|0U*4&{*&CUIu8LU}+ z|KmpU{kQk8SM7o|?-o3lb{&H_yO{dyL;U>m4R$6=`VZE;yXIZ`^mE_t>tCZCgcl`- za@!vmBX2(i2l1`KziU4vwk`71p-1F1M@{TLGdB0OK})cCk6v^P>_r>Vb)JUCWOR9#tmc_^p6>432w!Er8gaRS?UeNztk+<@BD*O&>U&)8 zZwlAzpSSq01uuL)XN?#6D>^NZ^JZ=6<$iP4Eb}z`gEfh5sL!`+$IpHrFu@*^gGuJ! z{^wy5CvPPKKYC+53lycG`P~iABAD983~F_@9S~_QXh-WH!Bjm}JHPlTpuk zlrtG>&djtY|QD)(MxKQsy~~ zpH^XqQ?lt-Ifr?kBs?nMODFYX4427N{DZ|owct0}EerTb{IQ!ufyU`Uy#yNw0O<7Z3zIi%b^f5iQB`4o}G>~u3 z`2Vtelgi`UpnQ`YF5jRtp--PK_<}7e<@*pq$o8$mBj9^0puwVt`up|SXmt_s9l!?u z5$MGud~3lT=J&jC4AH~!jShHg&n2E%@KfZ^X7Q5^WFtlWN%V2i`z1d>=%&aqO3w7h zZ_JGweWY4!%I|7yS(}XOt|q=%$wmBb&aEjvC)a0Tf8eZN1L`FFi8Drw54jOlUs1eD z_1|Qhg2UKHtDI%rH?!tkVv@QCVz_I!8{@Im>^U*}Ts^uD+vFpgq!vt<4_EdJ|EoWC<_zI~%&FR_ zX{e5_qprpy%8sIZmdOIX3vH2ldm-fcJP*#^RdmqjpB3O7X!QW1A+x@_Y>f}D} zly#nCx1P^=`5knOn&HUj)2Jy>y&tB9@$&;CfA9W{ zK2FNhIB$xtiEmc)6Xy@;B3&K8T67a^wUxxnQQHW8S$EJsV&@4RIS*ferKRn)ap6(! z!CG>;SW8%o#F{&)Jv%ZNSNwW~HJO9lhznIc9dJeLHp$j``989H$;BO89P)yAXzxG} z4~@NaJ@Ki`C+vwnbU$?%(1&vI%CswUf>>o0r>xo^pti1jlQBGWA?LpRnis@3)4p7_ z-{Z$O%QxKh9ud3jdQHCL4j#T$HKeN7fPYHo8zFxSFXz1F`T5(yoc&XBgy6FQE)42c z!{ms2grCRf{$1nu9@%~5PVMnh_|iUkp00Cp4i)!7q*Gk)d}AF-m1nSIJf ztZh;ElRNmr9r1+=eNgYU!-5Be-+P1aUU8o@$GOd>t;P-Fm>mQtHu%2VdpFodgZRQVgPQH8Q;gou+p?nb>#X3DgFOE!slNp^fg`tj7*?YHc@Pf4$UY@=}WyxMleJB{o+4?#c$}`}hJL z!90ppU4~>s^Jce+`L3|gxz62!9h`T}wYNp{*38Cl41ESpvH4q=Qvz6>E%ato{9?b9 z?kF(vIFp_khfiQzVIINxpCRLl|LneXiXKnro4niy-cctJpfp;HBlc_br9_M59q|9i zm?K}0%KMA4qi@Lj2j0<^tnf|SaxxtA&j57r0_^Nk&lLC=_(mjmDB031wx$sNPsMjV zv5BeukNxWLlY!ey})9n_0^x>VJOK^{s%7o9c4TrGsofTzGYF5|h^JgQ*s zM%sjS=?Vub+IW`8w~eJ<rgz+J;$-FHNpT+dejJ{`cu^;x+X7KH{K5_)Ghu>#DH{4)w#p zH}n1$89O+u=LYzszQb1;@SDcqc?O&!cNrTSzWbcMk>@$G*G@Qv{p%*-O@W_D=GsnN z*3SMm;%eZ%=LwvM&mx9R{B?@ekyh~eu}B#kgE4l8-6-jJNIdo10nY7?%CqQzLQ#!$PM7H$f_Ru?!#Z36Tl)*k8=G5b>8J(qakvM^h@2Q zEgm%1J<<_M)^L`^Cs^Cb-gXV-;L3Nz3o7}jSYU*$eT%e}cIgA0sbz4J7^1a~2OVP7Vsg0g_XDxeOiydt`cC_iy>N(Sqo2H|uOs57z4ex7sUjr`8P&$j; zlL;KfZzMjRK<560doRzq?+#z;*7q8+*Rcj@gs0o{4DWQw3_&X+H;6O zAclZA0^@O0#Q@^7da11&+P`w;#dXi2mz0*?+IAi5TXoT=#IA>Zn)}G{L!Nb04|mTH znpYW`v*aWc@a_8#IHUV2RnBO|o;B#Bq@gs<%ld}mX)l(F^_cX18% z|IO~?nfMV}N=Nz;T0ZTc+t$^x6pS3S!t1(&8HyH8JoC(zUB*g&%blLXS6&yaL*8#+_S+AkC%7Iiz|uh2Y^KY&5re=j^G=f?yFLwrpBeTv(-kDIaKO$Foq zS>g%6y?5Q$ARIgA`f{brTNB&;s4x_mi9HWp3||yFFg9crBOrF;vsFCwQEcCR&@Z#D zNJsDa{Q&&4-ypsKIm8y)80ffXi5y5hVf9Rntzee;9{x+@%y!_J>oa~x`piBA-N7CM zyi8f6ta~(=F?YlFS)BipPn$(1VqDd~wnyY?IX5T!R$xLOLuqu)s;BE3TQ6x_@TOaL z^{;kg!)U`+F@acr`1GFL(W;L3r2i@%ra(vb=bKCoA6M{G>50TlODwq95*+G5GWS9K zH!D0L`Rwp-mCg)3Eo>`mlX@!IX6{aG724W05M2jNpK7y@4MW=cxqZpoN9~u`8tf^2 zKTH=-D}PGE@G&JWO5_ChnpVDn=bIfPWFCvWhk&1V)+j|1Nd|AKt_Q5BeX#p?Aa! z51XAs-Dk0N6Z3;@WCc3P{5e9e+&6Xw^PP_mIp8sB&WVqtS8^{`^_P@>6ir~)dqmmw zM&SN%dy6MJc;2TR^r_~asFtzu2}xebsC*zgO3t~@8<^`-n;Z<*0qs%t^M5^8OP4HR zevQx`_$~K^#8#l|VKdI&Z}-c+Q^{E?HFfvX9W~bAyhJZ&Ucz_PytK*EPV`slm)|NL z&|d@XxTnf*pTFa3qTG2Ee51=a#^WMW6{)eZS1ls{PZ@Y{e{H%^zJ}aAP!@cv8H8R}X`~kz`!-`*)2O1vo(tgm1GD+q?r# z#7e%(+}MvCPBeEw%LANXkBm(cKhZG9y|u&4<3vhqROD>?_|PqFunibP-memUOz=6^ zE^$omEc4rn?ho&uCF2SnG|b6fHNVe*pYS(!X}(dg(~Ma0W!NLYgAK%VRem*(2f*+h zao}Y8FYHO>hR7Qt7Y^YqzD$BVehM{7?;Men1Dq|yqf<7R%T;{8(% zIosO>%3q?!j2A@{rXTazLO%)VXWo|RS?FO^8~Tx-(M{!iV~?o9-hPjT3`i`ZPiv`1 z0y|b?if)G7=s*9Lz!r0njN@51^#?W`iMtpz4}^VFc^~{9H6A32zX({HioQXoC4VP~ zhx|7Me`rh+ni8D>{AK~CGnxNc=YTtAFsB5v!%FrEI*I<^A;%I2Vk_N$>XwMI1$0_l zg-&2++)7SG#J4GSd?8AlhR9IZ{E1JYZzX@T4`<1moA67ar&tneh7RB0$DjZgffLVp zFSH)o;5Dn9HqKt~Jb31W(WRB|T>BBRo#+-hI3^a#-T<>veP+PQ993opXRvE*^=xt& z9@(|kt+zwI4W(hL(U}r?4m<8p`BC*V3hvVnbC-UQvzuC=6IG*~k31b^kFcX~9%>uV zYw`EYz-~56?0fA&{A&Ei!}nP2tDGUe6T2bzm_|f@mp#I!5bUSfEAMlCCu>tG2PQe) zg16oQ>Kh@C2NxVy@Hpex2|e ze3cv8^JmoHyb7IDIZlu4{GI4mB094M=@=N$OXX8NY-?)M>$xvgZpN$ z@G8+WlI)-HXo@?~JMcYQ!~qMeXruBwfm1bbsx=3coo$iW*&4p6Y->4qJt=cY{IjyH z0W;Rq$9jNS0lbxOw;i~sT-!X2X0AqXhAtNT5}m5eW`8H{ws|)MXNb2}?+xZHdF+VDqkB zCAQkOSVM;<`m^ZFQjb2izeRL^v5nKNi5UAgUB~9WG-BQ$_lC>9c zu1m;)<7|%tKgB;S+vlz9f%1!(B|iLDVjBeZ%7*33GM2x_26u3c$bI>KnKQBqdop}} zufVsNUwdFv*8cnJW3>#pm6t`pAv2ISUXlJ}U)wC9m#HW0xj&)eK}6ZGSL+o<0e!kh6Fa8FmOyD9nK= zjF&@x4eFD@GpdmTR+{Jr$h*)wr#KU8Bd^mbsX~6upg*39fAfK2XZ%df8$XY8*b+~# zdK#X%iriOxBu`v~J^#~sy0pPamp+7VGp_rw)rk){rO$=j(uc@>d=7ugeBIA=FGbhm zj42u#pKR1TH;^q|)JI?N^ir{l!QVfPpP6_h;E1lne(-#yXis#GZXpT``DPl{zJPS}gnvd>FDHdA_`~BXrUj zne}3qJHPau`Z|f;F@#43xcxPS+b79|3;6BVgjW0YuH)A+?>v5hM}{x!HasP`sr>3o zTb{yitN0zZ$ft5JzsMrt)fW6p%e__5RK{D{mwe7=m8hg*(c=4_iH&n7p3bMu79 z6DOf$o{q1Bn?5~;hblb|*g!KwE;76CE6C`6+g&$NW5!Z6pSIa4Rxji0_)td8A7Cy+ zaK`5`@#ye5vM(W#*OX6=`iM$yYeii|IL%PJO3MeGpc^eoK!v>I@2cnDW&M8$no|4L+M`Qw-ntIx*BfJ%hHPO zO@r=LL-%T-d+2580MK2@Z>jI~&lo(u&>y$2B~%cfKSEDrp8lPA@3t<7qBV(~g|_K{ z{=6u(MEID@Y1n$c{chLOcC*m`jyr)#uYcAO=P<`1`yI3qKik{V66J3YyFTY)l(u<% z7CaHUqrW&1+vO@$r`_{=x#}LMq@j716x`G-WRk_r3%_#!@A$|9RREa8wTsGW`6J> z@as7Cg%I%p)CC={x!g;j)!fbMihr|#?)-V{Cah|0qU7UbUVJC58#{(Sp!H7;;Q?m6!3BHDx48t^S=raGy1 zbU29}XkOE{g#MeGmpS38V60`!70nCA68Xs=gMO>Y`B!5w)-3bH$T2b=IieHQy72SK zy1>Wd{+b%E^Xzq69qWO@w^C=ea!bfyZ1Hi4+@5Uh2xu#`hd2VE)A&eBk^jhVWe-ft1b^`3C#dJpbX>`B zH!4|io7$VB?1|MeV@Q1~sW(!+0bb_IU-U(M+-QAd{^MkQ1hDu{VL#C-=o7LmwhHzd zIa|rNJG%#AZT9#vMcTKd9+s>#z^%KKOyldwmr}Qo^M|b`#rms$@t*41bABQsVpAF}euz<0-PTt$0iV00qU3lu-ot^s$)2|S134dbGV09%c_IXLT5 z>t>uaR^}x3cCnu#6Z9I7V)J{HoR7y=^2|nm*c|X0ADi;QL<`H z+c)WdW%1q8FF4QKbL&~ylbbW~C*YZ^g*g*zFgWMT70P#h6#3Y;um@N7`Tf`TzR&(H zQT%*341C(9@XLpRzsKO!2)>9PVZ^<%5~q}`ZGK8}dL{m@t&)0i&5iBD`IE9c1o~B= zbL4qVPIeNWBl@lA%~JOxunz?`2m9UG9JsH{csDi&?$Pqla|FM0x<9pfZO%IP+&(M& zILf#uu|e#|)-kqVTw>^zKm&0=q+g+=taU&dXNf%LabRrX(~j zh<`d|I84RH7M#sDN7LgBY(B}_h7q+z3;Dip``LEq@V+HSN5=Ll7i(??J8tCy&23b< z_<8xlk7+Qb59#mgV)NQ|^T=n$9V5n|f3cJM=hptQ&#xMv^zUwM)nchurnWU z8Y;6)NGtnVc(i_pjPFQ0<8|8Q^^@UoL*Skvz6(D-wH9$aeTb41t@6M- zq!t!(tjJm9{+}!-y10F49{9V-iB{iW<1EYrf44c&`EU2-^T2_{Kw!7nQwaOf^jVb~ zqUcWQ!NRr^*2_MfFZqVhd;DN$;s=|>{d_Y{x7Z)sS%zIrVnm=10d45^IKRpts!428 z=0RkVe$O%kKbLmC*eSEN#WQGoCG}>|Ymo0a-_#1XB*$oj@K6iA%1TzxAudn17~c-& zeNucG&E7%nF3B4)j7|6%lg9?qp=-H|@P%>7^_FgMZ(#CAoT(pkCO3BI>AP=-(5KB0Tdxnp2y8F6|Men-fo`jj3kxkQVtz9gPr{vdw&1$z2t%XDvb??9|~weFUd zn(m=Lj7@$Tf9bEOm%Mx;agvkaQ}-^#y7!WlS%^9J@cF=HnijWO>Vv54c^&OVdj)(A};Vien`c zbXliy5p@$-Yqsq2-gM-fs&8*;IrTCk-Pl!-dl_TXF2VOuIxJ%!RcllAex^0Rdylf; z@YAXe*|$;8Rbf0`&IUuRv%DQ9z4TM);K+&lUVyHIa`fjuS#Lm#*2;60*X85Y!r=KD zCj}f-?6}}t+yz%g@Uff?K;h_~@mkx0`Sa_}jm7H5mzR5c8uU8<&d=|8_jhRC_blD< z$eHs}dhE6RQqx0AhmULCOFMM$g=ci z!x>9*oV*2%TFfT5)&3kd{G;6C-O64)8TOVtV`J8ML+)31iuMo0tjC!D3_Ys7j$LS1 ze^i6cp|7te4%@S2oOR@KAOmu?@4HfD^>`$js@B)1&Jq8|5I$L0KY+a$q7%O>{%0tD z^)TP&ZLrXse0_i@{$S#|RQ@G#&D_O+ZFAOlkzaqHQ_o$_yD9b**R&@hv*^ZS4Tc-C zPem^=l8;%2w-lTCvS)x%L~{>?KVU!ul0WJYI^f?My1pTl{Bg>NC5iEF+M&gkojWIr zojXmPvsm$gIo^X)IhTh9yj9c#4ui8(4^*a?9oJ-konzcZT^jCp8%wp=o`XskPhZln z$-c$zdqa!8_L}B!zq}g>Lp#akT=;GBL(9?I%eiyF)xB_-8hG8%iX+@z(51z`GoYov z(-luYxmEWPhX&GpPwH;-7}GsmdPXu%t-E=m8%%&kOhGrEqB&zepn2cvgI-h-59)@! zuphG%{m~-Y8N><7mi3H&2Hz(Xt1^e--#*i?EH({j3*0 zA^rm52%t@;8ry+4`g-zF%fOytI2TNidSZHPIpb+|v3vXONHQYyjeC=Jj4SeWx9~%f zGoom~A!QTW?%Lsy7d}M&M{;PpZ9Tp8B`vu$q`A8-k#ZNuBM6&(PWq5lgl^>zcJy63TR)X5!Dtnnx?*dMI% zsL=0G;|-wSDo2-?a2@)sV?)=W-+J;Nejzm66yEIJx1D($r*3oj5c4_~v%BEwoUw&A zelu*$N*A<;(RAiUo1j)&I8W2btr?{Cn)r;VPk0J-Y3}51$nQq*a}*I@9!9SX!}r7J zwP9-GhI!Auliv-)_ruVEB8i(;vPlvCXJvb_|8Mk&6HfR_;$sAdGT1T96X?CzRqLtO zXyUW4$7kQvo1EUxeM6jctLX%B)Yu#9j|&c|b0fO2Reub*=0qUxZ{ho6S-W9C-3MIL zbSzoZehj@BTgqnaD$1tJH}KMF8>l522PV=Vei7v(%zTaSkK+>=o2 zH|_#k8%kQp!Qi?3skV@R7M86Sc}Zj~PvWfo^RPBMZf$?sqPC5lAh-5Pc#2lWoXguH zr_dL%6^5mGUwfdk>q&XKOUib2aCVej}aTrn?72 zM)Fg$HOF}o-j`PI1ZUH)eo;%mdKI>}apZqB2waFQsiB>#rLX$B!Z(#$>1?AN{UyKG zlf7Yam$&q)-fZ`)U9>mc1nWDzHWagduNkb-vsmNKmZ=h#sqocQ^b337+9|ScVk=Uy zqssn~`9}l0m|IGWq13ya-bCHY_7m)(oDt?C`xCUUQu@FXvPbM?C2iII(Dt~;Ifhq^ zO>SrWlD#4K{#(k^oa?soD$de6-HX8cLWj6(>PF2ouGE||ax}|;Yq?hL-96CPR(uLJ zN%rTVRl3l9k=YbnKaK3x+oOBEy}BDYtFa&jPzfg0IqKu$%{UwIa6NN zohyE(-g!MeM*7WFdiu@V@ts{B#{cZYwd4%iU9Y9D6Mvh=9U}7Gb6Wb%)q0FEkP&;_ zt4a-LbxEIl!xY_F-P7k@dj&Sq>w4YAjJf*qZui#Pp{+fkB=R0Uwxiyv%a3Poy@Omg z4SeDJ3O!u+duYNu@(_t>ZT&Mf+-B<0P1H+z;%R8+vqB#t$mNk_^_&QDIdurIbzY{q`V%vk`ntXm4Y_nhnluQ)n$y5Pa&}~q6dPDN`LX|9VZR|7bOGHkFpW)dx+d4I=?ZU zn1(iFissIE?CN6y-6eLg6uAM|(??#97nsTTh0lClY@65|M%eh6vmc9C10JG_5r1Tg zO@mkiiFN3%Yv4{a%c}O)$eK)So*S^IRuiMp-s3(;Ov`v|M5&Ii4zalsj8DM5hVX+EduK;068WaTU2YpT7~Uo+GkvC>Qf9 zws|=-?vkw`$t`!M%$saw)hZ*Pe>jOP|_tjM)7I%jIh&XeS*FS_irevbOlqwd%(*rTZ-vsvHa)x7J)XU*rOUXBv-WlFP;A7$krLS~P0h zy4T+iJPgD5ZH?wVe1j(UBBl=>q%Ju(G;W(s`v%RK`bXXQr~mNZfBh{Zmc4=XZxen7 zylQwa|Nl|(H!p>}G4(gV<2QO%dl7l^%U#*kEeA)=fqf~Q!b2!=f^#6v; z@15r1CEpszK5S4s9DSnVi+{o2^5+0Qe+n%?Hx_>wKg9O>d@Rw&{=8$18gi?J+-f1W zTF9;3`S25ocSeTAr-6@!`vjGbguFlEVW8jm3Y9L74C;+R_c8Bb@7U8at=t(C57jjY zFMm?6tNiOgTP^!))hrUV_}0hAQ(L{MC%a_)>0am_^p!(en{kT7<5U}SIVvIF;-U{2_GB&l@~@{Vd)bn%a&J}7faoCU=9}ka z6LwWP{Ch3A488S_eN)|s8_~0Yo&97eTe@eWXFngxM)pi(|7|b)WXPR(%#;`?k2+57 zfpaanOTcSJuOr7stu-9(%O2cUk#75_5&Os?rCVhuMk?f+*z%7W>Ef_1`8L_(#eM&x z-Q!5jg>3)YZs{l42#lC__TbL3>6ITf)Ll1xmtMI*&wdZP!Cl4ZvES6wHuoJi1H;b$ zlJ!?+AHIBitmtyx9d}x}@W*6Jig?F2GwwAg}i%Z?*)Rni8J#DQw z`T z=&i>LkyqF&%jo1R2YV&&oF!dGZ1Hx#uCcx34mn5Ju4jKS3MLIr}MnWV@f~!rs^?ykE|f!8!x}|4iUBT&i#!T*oJPYxJxp ze3AF|xYuweWQyFA$X>Z0!!Q~qQzHdGX|6U3&(RC0&A)|p7X#0PZU7VF3wpDkralVt zx|gC>SL*UP;{SC@vBBaOMgB02hEndNYjN=V8ScXuo+diK$Gv=mbL;q(FSo>RmGKMa zcLQ^o1+RcEUjfgdpQSC=ddPbDeb~W1G!yG!+C?HyB|ABHx5!!PGTbYHe@N-=2u~^ANy1Tlx)IEGfxgmANp8w&EvQC-1(_9+FF=xJt&vK!> z7x=lCiQEvs(QUpEm~waFAAfkGQ^I*!#XWqHDcGr_H&ntQFpPk4UY+La>d{r#1k^!~(X=`0Pom!+j ztAOS4oAsFWl&T%$nyurrhp#)qK71j+4)~zJ!u{TZZvL6%A1T>Wy8^j#K|1x|oIE`h zoH}&cpVZp^@WZQAeDL^`?mlCg#6T2{z*E&v;u7%l3!;Cx%QvCdp6SCXzGb18dSk#T zITN0ITDQ^2^P7+Aa)#U+uuV38T*(Bo->Odd^}E7GgTzJd(miTSi@d=2hR97)^Cug! zSevFhYZmc;hn6k2j=c?jeztH;%&%V7r1r3W%cX+ zOCRmndb)~7yjOj6*86=lKkG)iBBQri60}+JtZR4Kqqpe{=Cb%%*X%M!Z&PdeV=Z{r z4Rt{efyub-wd~Jd4c6|zYkbxVpA8<$`$4*->}Ebbf3T1y!M{(ir~k&jRjd9cZLjix ztT=)agX7_*Xznp(Y*4{4R|H@47jC_MhvOpcFS?(K46ZmnSHdA*lV5R$MAh& z%iO!&N`7j3-j?axG4~kBxpkT|@g?24^eO)xd?fwaaZU04#A_CDN%V!@9-dCSYp5wR z(YI}c<+~lUi(u!xx;J~U{Ft}wz7yFudb%9=HuGm5BD0JYSyp$OTF^bfpL<$DMhEK< zSXl7!VsgB~&xhP`M~TBq*z(Tj??+2Lo3qxuAD{7)K^=Yi+tmR+V+W+2yLdhQTkvnr zmvyvQa8wR&>@YYJaL751KL>^;@kduHm?@c4y=USeSnvaknP z*n>>$K_>Pf6MK+}y;$z73yU5rd=!4)p!2n z&4K^ z=lo~>n4a(^f4q8Id!tyEh)FQg>NV zugY1w9Q&$mM@uVu)|Z;y(J^NCdVYulB;N$vWj=;d;y{{u?gPhOOK5kZ)AT7_daN}G z{O&hu>#?6~PDz8#gaPSKkM_U_&Yd|xYf zyLKQyi_Jj`tGj)VAv=q1eGB}2uWcEPzWgTqo#*B0*O0qjwNG(uVA?oThEp=$fj#Io z%09q2e2e@R=saVv=a;*OcJMqdypXxv+cO*vp3&6fEr+H}#h$SYdK~C!(HS?XI9AU% zIDibGr|&{%c;g^?Gk)W{UkdhazwRD*LHF(|Q*^_-tG@@GzR$bsN1A)Xi(%up_yZ5T zsypT7K3ypv=t0NtbIN}VP5iCpJ^Wd4_$o$Ty2@OV_@+Eaz=sh8yX2!p4 z*u)2Eihj-%I~#Vzp0*mXYc_CZi1qg4;4X8pueF7-y)9d|Ca}F>4~b)&!`@k#4_dvG zKH9NE@5AmZe(Wtk7(;n zy3tWjP5``M>1OUVXMHX0zj5@9y;QY*xn+vCg1=SUL$uB4 zdE4x6c{ek7x0k!=k+JM`x_h`IB(_?Cxy(W3QNy29{c7+pd#O#Hwy8yzDw}BDuY>HN zYIgx6<==_UIEQ@1>OP6_#fC=iorxbu`EB40@ct^r8!kfM6aQ~tvH@RGG4aBU3;T?@ z7xyLS-qdH1>r72mMU%bz!n)96_5XfsymxH1(>8mDyd}KN2{ZR22kc}m^det}pq;Vt zcZ@oA{Cox1+}QYQ-tE{jE_!~*{pQw?A@O(O7w&v5kSUf86!7ycl1t&kYqQ7<|DAof zqc@%Eh!5I{cXHO`-Iw3=_dnI`)2rs3e-66$JpPc){XU)5Uh`##WlGl+-X8pqeMjh< z;1xe|uAf(D=7+(1?56NaDAH|m+#U>i% zeU$f6Y@$(YqNjuBH4+c%6$_1PdYSW6rS>u|KEKS5jg7w~&ZOw0$&J){*hGBzCgQ_8 zWIh@`>f+*gjYO#06Zuq0_UWL7R+lTRqzer42TD^0`w(W{7`|H?_9Lrn!Da}pnucg0` zw-mmEZ#^b{_2&K6BKLVq<@;^4zXPAd{%L~i(RGW#t41w*?=xMH5NI=gi|?an8%-~J zV=`wr;e?4TpY>qporsFa3bG^zcCRtc(BP7}V27o>y{3`Dxf$kfS5mT0&!qZ+kr+``ASM%{>FL z+a~MYMPz+K~=)sOYd-|3HB5po}nj7vwZ2&I?5M19hi#wngLMx%cB4Rc~Y zeIb-y`a+2Om5_tp;58HH7%CAP;@DV<_{%HDkM)+0*U}5-hhobYQ+MT>GGluE%dxqy zYjp;?SeR(zsQI#c{ne#)VdRa->!rw{VRvC$X}Wm<@dvx&UNbRRH zowftO#n7^gw}_2Ya4F*6v1N)k9{CJhN~eJ9I^^Tx-%d>Lddf)eo*$BD;27@{Q``f) zu*D%OZ&_=kmv4=GFHJ;lMjzfapLoJ^X*XBB&+c^wJZ(HYyj)8+cNku35wTPkY2Mxc zh#kKDKhs^6)bSs$r*~})#lqPA#z5zZhja{LtPXv7Um%AdTe0sFqvy-MAC$YH(P>Ta zU-`%LHG2H_{~$5){c`3;2t3EHq>Vbl3yCv>C{yIUhXaWS^H1<3YW zj>y`4f8$QpiXJw2--D8CzzgwHs@laqk7)?``;e(9ge~-4Y%M3SwQyhDJ?JAXA;~-N z_qF46AI^<4ke#%c)e8KP35jWd0gHR$^|e_CuqIL4BKb z%TXlLLC}6B#{r zLqEQ1uDpY+%#59;augL-ypS=V|E89?-X z4HyToD#S4vSLvSTPSj#$f5i5-LyeJbve_?il~~VcZHEqxkeca3Vky8u=zjw_Whq~d zK6Jn|z%#Mssrpe9JJ@T1>n?DPJbO*aI0vY4(XV9HhKm06i4D9HJ0<5@oekvGR(^QS ze06B0$`@yB<-5l&i%p`P+@|rGvt>N-+SvE^0~00Z$l1b=-`Xy+Q}6nODfC|MojbWM zfF6+C=+7Uz7sN|xFH`42WL(y9FE!Ogh9)+E_}nD<7-AQZcnCSaQqRDD&sbXA^j4f0 zNY9?FdmY@Nd9T%E8CTe9Yp%ITw? zQQ&U?e|Je&C|MJRUv{W?cu#EL4*_?`83zjo9sH(B9hNw@+Dp z#O{}S_BzcyyepFXPW*Zvd{S`UUA^6m89OxNeCRE)5Xf%j?yHO8A>eL$en`e~?={SH zQuw+{eD2NogZ|X(eyuB%wi!p{{}5;H!3FtwDSCvzIBlaR9Oz`O`0o1mU}xbRhS-~7 z=Np=#x!>&4VqxY%{5SpexX-^jR_-ivyXE;ygU@%qT9&4r+Y~V!WQ-W`&BVc2>E``X zi`-1xuQR7EVn2@!WY>1~tLNNJoZ~1pZRIR0yU0w=`wYQt+K-j)5Otn7PNbd~bs0aBftr zAu)!~1G#fR+Cv}EMcez55`VakGZoY*i?;6cWwk1`reCXbT-(&2c--tN`{CWgU8v;)octYEty9F>s??Z>iFCnnh zu_29wY1IaFe_&b-Olt+ECUXO>%+Ht(TpN%P6 zCZL_aB#va9`adJ<)P4_L9E%+y!hEUOHrhBoYS*j!;XmGGkQvWUv%8Xea^};te@Bz z?IFYMzQ~GM-_k`cRQZ}KsGW>_CAySHZ7tS946VP8sEWBZd!rS^I?<*BuR`z8U1^_DvF%?oK27}Byoz3D{+X<)y{0Z6&S< zAMpZPPhWdL^Zt{Zs6*dBD0RZb9t+kpvkhtTsw==mY^{1AG+@Kfc- z@dBKFzkT>T%2+;}-{x%KoH23$)g5uvH&bT`+_r%wd$W>!b`|SgqxhekCzV6upOar> zhc#pSFVv;>1vQEF^z8Y1?A$naX>~}PR3yg(g=P0KN)wnY}CEk+~t0> z1)LOH&8fD;*XQL9wMOl?;Fd9Dydf~q{&%+0Iubqe9B`go3Ume~v#e9}=kt<(kIZ|R zdA}?F6g=Bha+kZ8~$HmD1dq@G7?(PiXZTNQN;BHJ{4!L#DQSxh{^o|Y;a z3yrIzzJOEorO9sd<=p>zIk71TEjIfi`L-;!=rt@=iO7r%?_dms-zrfmBy_1H&= zEu1}BORvHoW?|Rew1KwRF9rV40VTs~3eGQNOD*!kGSqQb{yTL?2RQNW)*2N*lacb_ zlsZ*pw15wMU-+AhC;F)L?dx{c&|-C_-&OyDuWGHD9rDMR%~`6-t@i=xKReMPrWpRC z_hB?tq;$Qf_)Gz;g;ScxVjliD@@MqjG{2BLmz@Js4;*V{O9R+`ugFnUZ zh(ESf{0{ij1pYva-V^@($j2Y8$j6^VMD2ybt@zi34hml#f*&^u-o?K)h#zry{~&(Q zo;+$~>fw8?zRP?=_B>}F_Vt_0buy03J7&qgV+WyD&b!57!7*@TgdQik`%!XRa(8(M zJrcVg`jhRMBD;Lf^lO29X|jR+L2{nl;~m&+s4W3+cD4CMZo(v|tBA83oK*VXq{1d)TbTihc&S&C{A?xGp zD!GOAu}*ZoLHkv1?r*nV*5a@AUF=_;H^6U|e8jqPw3gg5^kL!@3iq#ge%RHDN77m! ze?LzwtJ=RDO%3+%ZsK#nMQAMdFw6c4ZU;2)9rsMys&!*~6MK)MpC`Fvariw~Lv&Wn zs!-#yMz8ou(<#a1*P6_)br&{2aJ3P8PpEN>yS&I>tI3_QR+Z0J)LIjtVh_t?P3XC1 z!S`k!*F(T+>>?{S_q?v`=NSJhcFI1%_nb{Z(Fp(DwLBNu8@`aI;XA+)=n(QMHo)ve zi@G9OINvwz25lf`CD zlYM&gjjB58i8;lWO&%3*LpM)w%@Thvp`rd>BFC#WW@><~s(%LkMZYqMe>fZ10(*Zy z*0NU;Z>hddURcos{7T*L6_e|saXux!P%BlqAa)VHAN*E(9G$%f`%|g>#&*$z?Seb# z+Iy1NNTS4=p!E-El4mnw$x41tMJs!RN%sbKJ z(c5SIz@W~EWv0$vodsyxy6#&FKjMSVP3F$MY-_HpG)ll|Ir51v+c8#q&P+mtqb zd#i5yz^J&RwVduIN(*S-*}$9FPXBy_z@3Q&@Q+H2joY;4RNw{AB@ZHGm*we0@2=7q zwrE9PDjUb-&L(oKFVk@+gu+dDVh-j$pJb2m?*{nVE&95`w-7Rp)voG11vNvPh_UQe z_Dp^owI=vh556_|_!h)ksyd6+IeequwvTUrf^L)!;+w29cSaI#fg8nYoxU9NZNV$> zs2D!_H?gm(@5*dN|0OO!_!}~`!W&?af1cAH0{9*DanZ+D^ywbzlZ4z!#N56kZHm7k zGLKJdniRfD-IeTA>s8VBMMm)Fp<<(l)UZM}Fp&*RWCIi0Wuh+|=*tHBvVp#Apf8Kf z(64hvU%7pPruMuOjuztLdSkQHar~UbgC$$qRX@b1ohETU?q525oGPOphti1yT|wbh z;$`rv$`L*Zoc%S5k4RgT$INt_z0{?BW0HHMbCUSak{6wo3tt%AX6m6%-)?FIN0Qr3y zGTt-n(}ik2dD;BtDRMUC`{2C(99`rBb#{Dya+Abps{TXPIL^pi$4XdkXp_lYEVpcv zf0jb%cY)1c&O&frekwYGd<%W37yR&XL-_~KAGs&m8EQ|;0^TLOzu2yF?=6}-^nArn zqZYoeGpaep*K&@~fwhmTdHefz)!VN#{uA)yqk}X;`(J8}Q^_N;z{Ao_gZSP6-L)+4 zq(I;I@%@L;mviM?<`v)^cAc@-xoXT(`@_K*83tQz6Eectob}kqwNu|-WUNrZ+Dq-R z?!!f8g>dEDasxcYKFU2;M3adBv5i}2V~5}5%Rt5Wh7`Uv z%oluP?mkaKHuC4NpMGu(`q5H?FSIEWc*}jja&Lm*L2muf7i2k~9?4o1O`1Ynm)Iv2 z9bYtvqiR1g-)8+0zd!7H*uC5)^eyT09<{#}yjS)&cwgWjtiiYa{okSQ2mj9>)@S0I z?7t~}QkPZc7u0f(yUb6Wv+N|B`x($rkS%0?iL0g^_lLC#AAvV2-lFVIZwvdt7BIpe zcv4+!CVGBZQAlFljmOa+Z@oMmv%U(hFpuKN_#LsO2wzb&MSGh0`D+i^jrqMPwd;rB z$2;mC6I^9?`>MjPh<$G184u3I)r@tHPdhW8^x-icdL#UJgXUgOydnFEY(JDAt36D( z=&ijz%nJE&{9{h)L=SkVyZhjogE3OSQ+gn_k*l>pwj1OR;9KGO&ir5OnWB9@uTA_} z(akB$)f#KM4{sbcubK~tjOedPy9}E9;aq=;_Kp>t((VVR&JJL4mJiF+WX^U~@GQXn zHN)^qn-9%B%h(9sXhk#B9&+cQ`_0Ry$BO3RUlE-#W4hzE)H=nJ{Jk7XBh}q$=t^oF zd?Uhd&U7CtnpLXtT@`nm(V;`~IPiq*>1S z%{jmG+n4Y=+IjXmaJcp40p64myU=eKw<5K2rq-J^9|?KcEa=WV;8sZ2WPd|?5b~dJ zf9rVvEj?cN&cEtC7-Nm)j7c0$iO5~1*hB7WFOs-7sSD}Yti}E9@Cj^6#MsE0_8ZX~ zHEw4fi};V8SFc6f9_ua1gDwy8Igc5-7Ip0J5d8QO_(8l{pFWz|D)K{athE{ZASPy2 zh#%C=3fHIp`1h-MANav-bdm6xS;sw-sf1@p{&>;AnyS0t4KKqt3iP|OZiD3!y>99( z@GpOWe~28S=q=Qs<0N$K6#dr*jd^vh#M(IYdsiK|_pMWqsp80K_%H|IzTUI;&_|%> zPM-#RKi6X`jq~esBdwo*LYnun^hD@hbZ$Z$e)zp9;Q#5s_rfoUx9XE~-Cgv`R90vI zdTD+zo3(~dh3}ut`<()_$eNCgeih=%SMU!XK)*ONglF%2Tk6PvY~2!cj)dsHS+T_; zSM=lR?d`Fk30x&M%1K;8eB^F$G{RMp=WlG6{h|gvFbO{@HUL+USJw?tLYX~pVXemTsrb6C6m{vyOF5bvBQ;p48~B>oThu?p`zLz& zQ7%-tU)ae+t^h`!bLf-sV2OVA$8s&|pYoX4jdU&qHCI9#!%6t($(f1g#r0X%d))_T zYY*RFWUiI-D6!z!uhH!_E`;j?pCLDY9J+NspYEHhby?p$Vs`}hx@4WR7qM1J{B{oy z^V^m7@58XOn?3}MjSt|moZXD0;l{=r;(i@^LB$~0)Cb5NA-xg(B$Rh}rXRomYd}9~ z4QWY8PZ#v-JoK>9F!j^^<7rXryFybm-Nhc(kIT1$%l&kh_``?WBN-;dXK*jkKW<1X zF4y{nUenB;h^NNo>>+P{WUe%4E)n*BfAN;#G@$i2oZvlGBxt60ocFX~qQa3Kb zS?PZ`Ot#`Y>)5sEJhNUA@434@e_#!k#JxrBg^pbj_m;F{2Re=iX`IeX*E&lK`Y*C# zku^%_BmO|nXM@U0oZAUvva*9>#!|~y4v%wFLT_6SNPKwqxR|WtW1!fVmPQLyo>h=%na_8i!i9&tGdoq{==6Sw zY;i~P8E%4j`ZaCDRkKFPOHMW~CJuEjHF9qzwz-MJ)I&@lrzWubtdC2L>TDhS!hXm09%|QTU1+_~ z`2qi9X-w#vFE) zIv^(@^OyJSoqIj@qkQ{fr;gZeu_cY8{wVY_S7aXuWy1E$LLD)!Z92Ia*ENn!px#Mq zjn^r$yM60(iOsn~*9_N2zCH52ek*5N`{1jiyit+usGruARt#M?^-t{AX?j2Vp9y91 zfwgUY1e%L20eL8PybWcDJoE$PJbV%ZF%2O+>FvBvej9zUhODF7qt~&>I{U-dF}+FF zF$?aCy~CFrx5WFslEW5sP)nm}H@!pO?{%t(^G_r)?riKB2X?C#sjY#(M8}^kS{3>y z^m%M;BEE{c73q+ND7$R9Oxd~!SrlKL*tlBDKYk5c=ktAf9|!O=l%WUKFf$kY3}xt0 z-WsW8Xlz{IV80BV%eP+-_dArK2fd%=eJw-hlJ@3^?;-D~aUTiaC7Mot5BP@eOGwWi zVZU^YEZ>U`Tnin51{@;qHu9H?-5DFJrR}q-eImGNd4<3>{Y1y z>9r2m>s!e6T1Jk}Q#JpCGnwQk82_&s|G?1mG+XQ2gT}v}@%HQU8sg*#jSJ=04owS^ z_PU7YANO9`%Z;<%Lk@jLKNq*3iD<(BEezqmj`ROCve|#ibLK_0^lulRM&1zp3EUZK zkJIm}tKna-4eZ-^iTm5D=PR_=hV!)}Z(X7u44=OWePb>B=@ofqU`+?%zkV(=1DR## zz&B@l>9-*Z`Rr1j3gyXjQ4UTK-JS3U1&UiqKk z&WFYq2@mX#r@;0jdBo7AV?OdgpFEvC6}#;M`p97`OO3~72JH!-Y3L4PFI&GSG+p3; zM<=0C@aDE-=Bat~re3LI%&|d8 zNZbc4>(q9f82cPjN6ZR>fA|AVFmfr*buIw4~2DI%=>DcrQ_t2 z68Bya^G2;rN}Pe%7g%RxWd2T8U`I%gruKZ?kr?^>C`NwV+W7EiB|bhg%8{7+e0+Wu zbB$RW8~$7?aqJSq-ujt=c{p$Rx@IN5!+l@y?y3W4k#(1A+tW653S0lbMAMp`$fq`W z0_5}4OK5UKSC;x?$WaozhOJ=OHxN&+3b2t3!jaY==gO_Uz%X+7^J#e=_@ySKz#w>% znV2G4T;mo&LKF#w}f%}lFuMN5q>i+lMqW zJUi*-j>PGYv9_Uab;+J~8U7Q!kF7t3?)9c7LWjnGU+0%QP1tnM0sO}HGr;|U`Y^8cNe!zpq;>WTc8dvh z(0Cm;HSkVK`cS{<4IW3Ii;sxagI|(6hd!1U#72*eep9U_+fn={9M{5+0>`Us2c^hWIkjNi5dRbc+l+l zM!p%md;{I;P&+Vd8J-&P>@&JM`)oM$Uvt0M%Ku-ae;xH0>}6?*<@es3Xk;g{X4C|c zeo5YeUGbD!&pWNu2n^x$Sp%JygRZ4{qLQwYf0q=u#M)X{fGh+>Pk%;F?B%FUiCO!{CM0l&pQEb4Z-IS z|EHem*q5+ovgfwo$pDUCp#5lZ_IsFJs?X;q_NmZrQ5WWBXRNr$tWx8_vFpe^CMJct z9l`u6>R>df+(TimGQLz~<$dgRr6K2o*cj?mDgNFhIhuM5cfy&5D|KZ5o;>Ft!1G?s z%ST>_Rqr}Qnd#ECqTf0?<_%t2Avm9&jQj+iWOTf>=yPHI1a<-H{X}Q?OzgG9tMJa5 znm(6{+|e&L9+%I_dJM5k5ievAFVr977}64}DqKrDs_&QhbKknoqL+G4RNLZj9q4>m zE5SzhmN;eR*ErjH$w!^1PkiS0^~m>M_{Tf*t&{)1apu$G{(pSt`{}I41FJ7*s_uN@ zC#lKkG03W3l)4#y99ZEY&QkK>XF`+tHsDPQjqq+6g^sL*shyS5d*1mKwyIHyGCurS@p6#~VG{J1K2rQa+FztPFV^aF} z3QvX35NlXVEri`MSr_TuE;;bwS~XxJtHoAHZ4v!_%9ig7*QbqI595v0<12@)&)~HQ z=|#u+k?pRCcusWNc+b%5t%bbPk0*nBkA$>?J-yJj`)bjdtEM6sTe0k_CTbHv_g3*O z?4d98P}9)XH{`y^x&mKnC3Xk&OnhPSKDw)AFri=idG)`Mzq(V8)8it1miNR~53Z13 z&i)URJAgOLOJI!Lqj}V!yjEhvhwvt$<5D{}qLIH0e`ki*k3m1tyi1;aT4 z+!-5`+w}S%`1S(d-k9`)O)aM`8}J3q7U#XASL(dw{>ko^SiT6ps#Jy4%ZcEdO`aOL zU4!O73%^lZ)<)*4K5VfT)c8n@zGh%O!ugJ051CJ|hs@Wv9`@EVhpfkJu@jZ9G^mB;{@CLnynl0i#!PXJ;de%%1DiZ~w!I;mAB1!4W?(9BN?*$0dW{m`V&c-CCmw0(6AZMuo~h_l9ls;7D99{gR~qR(5SW zb-b>`&ud+tU1=HSlXZr>YrK(*Thm=@nF^}8KX;jNJZ~E6s-+>EGI}{Ig0`^%eB6c3n5XmtH-ZKGw-A>Yb$PQu}FN zFlR=(C1D8dFY%Veun|(b`BL#e*DL>0=$QTu%=&j@^xGn?xL!GR;j=;KNW-;CYl1s1 z_zCaK=6>T7%DIB~EdHLoi{A%hPJN?6Ts`(sWjk9(^39L`kIa#6T!oy!ZmnyrO}EsS ze9dVo;|xrAJs90AzDxF%{_gZc@(U{P5&u4ojJj6l??2y$jWVNk(<}L&D2+G zL{2ZjhE-Z%_}{Q%yapu+y`u`wszcA?k1K!5Mm|seL)~%)NNiBT`(w1wbYn)PeQoVd< z?WS-nwLkY}VYh27(f6FIES`_%(mF(DPXAot|KIPQEBrshSo?k6aqM*dgCU)mhQD6? z_M1db_GSvNL*}=a#Bz7EkI_CQsW}L5L!W!Wo!fz|T)RIDpU*zdb9YiNo|?D8oGVoD zEVwr>W&~$l0bflRF1?Y3x8@$+-R-F)F@hO-c5R)E-m_oqc4DhbRczC|6&SXlBXxT- zR}Y?lWH@i_ekW18$+cS3enNQWA#8!1zkFhp;PKf>z+u$^a|d;lJ9=~R!#!^0VRW=T zikg#Y#$M}vwS6S|)jIuMceNMtZrm4n2HC|)HmsF8Yd(GUvXhf4c&3wjw)`|noqg%q zexVB1mudMWXxbdgFAJEH7@3^fHMZ{?vJ=~WCgY>ut;=b*?ph z4&nc)ij8^>w}1bfoB9axq}veze< zHF9&dmgsSb9pHRy6n)jHMAzp$$eQJ@Xn$AtC$}25_~76G&a|e$JFXGaqj5a55xo2L z&}TBA3$GD>uAfPFfQx&FK9iPs9j@U&*3YOm@NmC*I{O4Jat5F9W=ahXdV@g!z4un# z!r6Q>HL>AI$=k$_yN7t5Cy1&2HMNSiIC-^eeKWqvk1wGQ)pBfm>z?GBl=saQH~S0d zhXoD?fxc6QaJT6V_a-vJ%)7N%lyKS_oGq`lRoF~_Q2Uu&j z1gwRd{H?@-4Zvzo9S$pN?AYLwz?#^t*VvrQxt2WPxdqyb!zHT6FZ7i3Kf6Bnk&&uo^M9qbH>8mIWCfT`)Z zE6pj;kVcCdP4TsE{#8awt!1z1LpO6Fw4QIeduiHVG)CjHriWI;I;pkk+Q4sPx51t+ z^<_0IjqTVnpoa~+d)(&TDyXDa$-S%6GN=FN#B|(yte5XOo*(Q!AwMvY!8lvYe-84d z?ffx#LJ{@H)vOCo#1Awt*!dLr#W&x&^eoY>TEDG+5YE%K?vu`==SY6*Y&}Qe zSa?Ch3)BG!$AlL^OJ4}bjKA;)jk$Q%8H4#ic0%owLVt5JpZ}5I9QKAEdEaO+%$^>9 z(%bwBa;eB1(EeMrzIG$Nru;1Y+uMm8*JMGf(KkESkM*Hjj$OMcVBdtU%DxGF*cC@+ zCvtA!+d@ADM;)tO&wO|8hZlZWsyeY243EIB_DfJvF5yps`r@ub)D1AO*rYzqxf z%3S)}4#+i??==(_BGZ{E^%Oo$o?V>J|GM`iJv)>sy{5vkT32`n{;VLC8E^QDPSf?| zymx+(zz+LFs$v#$?@}W*YPQrXoq;`L2KI~@*fVBe&zO#nXgdD8>Ex78C;p<|L{}lF zyx#o0QBO{}_=>L(dq-}8^v8foQj0C*uIB(N6zSSCyrQQkeHC`Lt`zzmit*`FYThYC5M)1xYcrWv2c(47I z=-%zVb)6Z?4Xtm4_v*eC-s||bPe1TTrubEKZ&vi)jm#Gd@1?i*!SD3xn4zrlM)d4o zJB`#1u}+oTujGCu^&%^& z7wMvVR{L@I%6$0R(RTQ{o)t48we)&ItA< zjNGE+Ilpye8xgXuQZfZu8@c7`}6}=$%gUNYzr0&WY05 zQeIr_&Rd=K=hoLdiE7tr?A+I4p>H;pmUv}J+nKk&*S~`L+c%aQ{uPs>-xo%|=S9Dh zhTIo^EYAjqJK>$3X}5Ea^0!Y??qPU-0y%faG=3w4&tAisZyus={!h+9PoWRdGtn;_ zccsy@dxJZ+tLhm}t@hVXS-06u?2X_ZZU2bQ!YiM(?G9LAqYs7HE*^T9*vc_1d;X z&pYyb?u`QUJ$gNbx}YIrMmY{E_#58cwnfY3AzU{(7WSh>$Z79BNu3k)rV&eG{)i>2 zdh5eqA|GhE+|&Gj(cQgX*JBnsQFre4RRzRa6aR<|N?xj)zdY?OS_utCX68%_y%Sw2 zJOk>_1FN1os6WEDelha&^J%B><=)(we0mYS-Q_oG>die& zER)2ZPeO*o=IPBm2)rT#!H4#(zQ=38za{d@(uweahD|PcZt(a0BIn6j)H*DDXqXOL zfjo~6EAn;jVdOT^VWAVb%=#k6+3z;4Vm#4do8fz9*!J6gjjW7~9$9YZYHX|UH-X`< zmOCVmf_`ROkQw&});r)Kws0GnjB`tlcUR;lGX=*=Md^mO3b&>PrW$WO%|5b4uiY}cKA`ZVY0O>gHKWWWS#$6U9x zUne>o`r8)vZ@4{x7?DpR4`wITZXyORMy~Fq@*VK}>4I~8_>;T!;G6gy-|UkW<@sDb zIo-O)1?ykde5v=FEB{vH6nD`K;#TNGfsEn)nI@7+8j)4v+k4!` zdLvuMc|h(DnqEq$6tPeHrvIfpr{xoUhBM=2KIr&Y-KIxsbWPZ+?3&zy{Jqeew~jmS zr-#={h=c2w$9{=Szjx?!t&_uR=;B&t%e*q2c4Q`o*U-iFGwEOG^Vvi#K+Y9$iQU=B z*nLik?-e}v6?%hNyU8zV`?XWdxhsaw6pGFJ@K>CB;hD?8KlTWn>TEN`{&9vhPA5%b z5|I0MCJcR6_Z_P99~1rd=^AITQbEJhhPxmjJ{|qGB43$5!cHykHnjEXv)+*D^>$_w zjJ;ptPJ={?;g4w8By*T+nfCzkzdY|;@IkL@-lW`fFEE0*4<610_a0Nh%$v}AzJ_jl z7~MAhRcdf-_Tia2Mu7fA-g~15^jn3jF4uO_M?~mK*P$==!Rp83dxM5`{ji!-fOW-j zu*SdDLqDWY7f-M!0`CamWnDse6CVTbgCV?gMHg>5<}Hq=HN5Ynp)E0Boeu6sx;XIZ zYddFXy5rq)_)mRkP7vRhb{F)Z_kBQIWjtyAXoNCT&~xagtfznPE8u1Xr=8#&gJS~c zTyz{+*A>vEXkE2V{Bi60&>_xpyec(i=Vm`sp?sl*H?Ild%*4AiO^oQHpI}Wp4^Q$R z15W$tnjro{xSpbiN9!qb_V2yGd7Z4MzzHoCIPYC=2%c#;PYc)cL*c9l*HhE;ht?ls z|EHvcwq>>!4H|wo@hKUhme*l*mI88=-SK zMv<=~eIw!}nlE`*J;HfuHDnz9?uCyS-l21`TRe&`M$G=+D@#)qM~Dl$5?$!;MHi|< z7pg)RszMj4LKmt;7pg=Tszev6L>D?6UFd9dp|jD2&PEqZa*x(m^n0zv;k`b6W$Hg@eI=Z)DAdE6UmAe*>8J)zx-im9?$Wv7 z*yEzup@I|YZsB-&(K~k!eWx`MUH|)`*VA_2y!|@S&~d&iHb1R<>g$=laqb+rmbTfm zA@MpRIXibOxV=w%kpG-@yr()mSca)w=-F{KJ*eTxE=@(ZJ192vC$Mglx zQ~6H*Yejzkz9UXSs|xveYI2L-RCgQl&@l%6twQJC}>9>u>wFYt%HBRxDv`umO+2LpS$zr!v5#xT@usJEqg6|?y7G~jzmFV-%^v?+d&>{I?uVSu*l1Isol@I znT3a`uSZYmtk_lZob0~;@^17D=Yw~Oef3U}H_oy3d{@1ga28F(&iAtIW`W5xmG_!Q zyf1i^-M7#C-M8su23*r$wDfcLyd2XonZVxa#hpb}*mJqo_wH3Mn!ZhazxO(J%l=D` z>lA%*fYp?o0e(YYqns60A^)>J#33BqS1fh-gI&+_&Q{(*uGc;)_Ojx{xsTAT7<4NJ z-7=tC26W4SZW+)miA9SG-5QL;*a70$sHx)_<{`IOr*M`Um%`7wtLI{WNzA?9PgKA^ z;yR{MVg{wB489PFE938-^gB4vozl6?2grAjd^qee;aS}92hQbx`ng)g58r<_KmNNm zEc^6xsppvMgfZsK%U<82dj@&C*TsI^mOI-^Rm*hjDpjsq zU5X!nd!12z1^bsw-tRwz-gLiZIDVbs`;CUXXP4v@h@FJ~ksA$v^Un?EvKQ$+`l1n7 z&(g0G|4Zx&<(fC*FS%3smrcTV^c{Xri+<15zgtZ3Y6Cj!M*KcMk16v4Q>DhnyXmRk zyQ8a6~t`VzdhG5Z|W6 zx>vc*cjzmg*q#pV*r1#l%rCzat(Gf(+UZmAFKpv1T#~>yxX+!9ZfifC@aH)t#2OG= zw~Bb$UD#Tm0RGAF{=I5NF}?9rJF?Tdo)t>^a5vDeFhk9^{`KC)dXIHxQ)iF5Kh+cZ zug_+G^mF_^Y0&d^Jb#i?)});2O$KqdWwI}_KT&;*CHQpF`BhSSwxu4|ajB!787HY~ z_Nk>Z+NT*84eV3-CgqRJGaTn4!*}MhHov8x{E-vylfC1=w@;tpJjdcaD`E$FQs$^$ z*(b-2_KBK1E6mG#Qt_ERE8=nXX6Qb-cZh#@e2?E)8ST@Cw0lR3-lt$TzuBk2!f(F~ z{)R8e>DwpzOOUhlG5gfcK0zO?*Lzl2vQOiC9D6zWzROu#@_Smv-ql*0qVM>MMydIi z9=ul*Qp;KE`{OEw0GN7!pQSpcH-?NCL&odxqrv$#BU(5_F3@o}tLnfl**hCs({VW_ zro;_phtN>?e2kbM>iPbunHpb1U!I|IfY2hzgQ~XGJ5oExp;m4m%}q^igMK21$MdOk zQY(ES%ILRF>`w!0MgQ0`+{jm>F+AFV$Id?cJfK_ z`G>ZrRln%XuI@l4g;$RyE}{N+y@J=?D4cl{PGd~QX(ZmgzD}9-H}!h)dea-%Xqpq& z_V(Q~r`N%YT4ULIbV;7cmDJ<=i1-z@27Rrp{up+)9&`GFUUR}t%#VLV#-95mv<@A3 z(lmVen;Edrr zWgQsPspp59C@wj-{(_77W^(g}eDg~K-%LGsbCu*(UBo)doU8-6%KrTM=m86meJ-MA zX07sW5}ibm*Uk6H|935qWmlm$pG1z=1Z)hfr#qjx(g}yWM6I+0dOUBFn?x#nyPZ6W{BzbR*$c)JGjx91Lw$=o8>QJW|Pd;?HxnfiJjKwp= z0e))vN717Z8@P^lxh;d%m*hnNe)SOwe`*qTj1C3 z?0*4H%aj@{sg+MgFkzP-2Dds%a=pl#*EzFp<6|||1qSPIv^ThWmf;?}$-sAQniC7b zWr-2PkH;Dap5|iGZ%Yx=RY5Iq@V2Bm?v&bwb9JfEJ2N}+EJ)N&}Xy0WX;W1h=$?qrYUyQnGA2`Lx50)B^8HT`hkH37KC z8}7OFM()=7!y5Jm@N6*bign!g!vmbT6Xu&htE2vooF)8VKKxtPe~GV;WmyZ!!xdRp z;P5TZ5^I33nBV%`oAil~30{f}7U84;pE0tGi!H&xmZ1B1Fn{a@!Ml)7eE2h=Y<@zy z5`P~0 zdfoZS8fPB1OdEMCzM~|Yq!;^Z$sWJ6v)J3aS9!lfHYLtYatr+AWXa?0_LJwx|MWg# zTx0=R_oybpoWA`rr@us>*7icZ@5Gc-?+>1tkFTQCK=)JruYSUw;O{)WPPG)$;~w4F z{f9@0Lw%Gpu!{Or_%(=Ski8aqG;khU$u0Orbe(S^|45%Z>eyp@((rIThRGS&lJGf! z5A>NpCquvfzCtHc=wu>8gfa;0BYYKEDJ|=s+ugo5I|05t0iv)1`1w|u?^BI0c*po| z<4rX!`F!t!u3q=M^?dJ@MsW5lBX|3(gZi8EP8#~n`t0a_U4KvyjKTc~b&lJW?VJs8 zu^}%mHFeDi;OT^^$O#xUCw5?SXd~wFySi=!d3)4PM^>P(gqKc`ei%S&L8Hqk*;V?;|%_%Wq~XtV;(Unb3CBJT(rV?-GsXFg?$3n>M9`^_;P$L%qQfc@Ll48EswY$lWRG(Q9}m#%xk;w=;So{ivtv zXM8(z9=>S&-P4etm&>^^ByLs5Lno$5Y!^H`5zp?Bc)w(i_vl8I-La?F>)ruQCrzJT z#rT1aWuKVFZ~DpXxKR1emQV6GULpS<^`E`a_BZM?a@1KSu-cq?Y7Z`WGVLra)x27t z-=+9@E?$i+XvO7Bz*FKTGLNh)KEb1rZL9?UEc|4qky?Gb*i_LE;75y~fn!(;IaA*d zew5MIe8zEp)eJ9(rcgh*dIb1A;#hC+4?luV|A@2I46n<_R>j%kT*=uTe70oX@OmHL zZ%rb<#C@GFt$EL<+HaBZ1va;FK}|L1-6@pw-Uv*KjNsf=M(&nXADj>_jsMr~?H^`3dz6k+JCYlU+Ms`K1$(qw841 zv%6d7V?UU`>7UuFxR0#w6HAJXJ?$=Bt6B)6Oi*Ol4Nlb9l!xK)`Ji&v{=rgsC;n^6 z;jLSRy@>iwONi%;_)>OtyJ~3^TVd&sg)Rs#48Lb_uSDay_-a0ifA#aiKk&S1-MWEw z$V+lYSO@%BzWDBmUzNSfPW%eI9-1@-o-w7NUw=zYoOvvjT-m)M83&h;j~iJRaMfpR zoCI=(UKjO+@LrrXLoczB^XJlYNZ(6;o;5qhn$Zh#*qYH(^^dk@pBSH6!+3-{pPFZ< zDn=bU@mjWN9&JvcX77|*Y|0Jj83p0`ejeU2p7lL_(E6Uj`o>vb=nTI84_n`p+N_QmX_M~C;|3#_}}#M&o_dkgWkG+Wm|&)Ns*t8)C>Gu|I>?LRfoVJ|-M z9)QD^FMe3TTj3dT@D};hJRKbVk;t5)i?IgOq!AmA@X1dq{{V;XPi3~R#9zu89&5$I zb6cs;ri|G)KDrk54PWAak$us>6#5tS3_07$@SQq+*886yYaI&Tzr9=PKbk_D?FMR} z%{-bq(o#C zkEiEZ?19*{R40@DY57 zv6ecayX}`bc3SYD|Glv8^95r=_-3!c?s}s8WBArj-K$J$Et#hyzmF#l<5cqA$Wz2l zq3izbQOF5`qhqbJQfEBSMZd)mR=$63S*Le%3q8&!8s35`t*5zG6ShOKm$aUe zwJdC-_W~1k(WCS-+f04M4$jTNqg&I`ESkr_oc^m@Hgvur%vhGun#$ReD zw(IBdhe7+a4%639=Nt4^0Pj`OvztrIx|PtYb=}m)PCEw=7K<&-%Wp37ZvOg&?1b8* z0Wn&{dt-aM*f80DV!MudQ&-CzDeuvXQ(m%wIJB=|x2-*jeZ+7r{FST&a$C1|mB5nz z9Cpkux8NykQ3VyI^zu8soprss#YSv_ND? z<~=D3%;wZ}-SmS?%l8Gud-RV%U1H?0q<82kY?E51j5%AMCq@lC!G4X5XgFI7kiD0~ zr_Ti+?lmN4Uca;NshES`*e$%*a0?b1gVvWCs>;&i&^OH~s2KjtL)M$X##{x4`=#aZ z|1S-HW|{Sd=qv8RRl>uLdf)o`2(KZZn9Pe!xA7Z#-F%DneQA}fZ-L+}^Txf0E-oM^ zBj(-u6`uRnz;kb|N;>)EBgi-DXEWHfzmjKCCsNLVd3yY4cH%Es>#J%4#?OwIwGQoC z#QPn0ZrHPsu77Ax8*B)1YzQCP?@i_uJuvj!Zg@h+)pE*+ou8ZY*)~+Kxp%Cg}AovMYEsR`4?36RsomSm#fOyt+wd$JQ>V!hX= z1M4TOXJkVhN#E8%^8tVCcz=-CY4`?hkCE>+J7gZd`3`)0_-l?|6Tw&fHa+y4i>31M zg@^hR{YIw3kD!gvbWO*hA-XQ=)>+V@gC;snSjR0NnOwgoXCjkuwps=_0sgitXIY)D z<;Jr`&h*vjM%e6aJDJk&wDqJ4WWF;sZaP~h7|ya?{q^6-p)Qtp`fI@Po{lT;e|Klk z3jKbXJ*e%~F-l=g=Vu4+Ya~Y=N}chUWNOOy`PP3-;^WH0$Cbx^=8K*q`RV490x$Y1 zxa(bR$NZ%iDeq;mqY__XFDG{4Cn~k94Om;{nj!!D31X*g&f)HMU?84grRbT<20Vy*HvM&KC3SyRj~9NM2M*+A$JcOPjXZ3%N%lBD`tD)%c+Ay} zAwHB|PkkcxscgFPzKUUJ73+X}Ap0+Iq>S5NLuYhKe1$K5OTIU|8l2*}Ke*OPj2OS; zYOQ?4c+~fs`p2)`@{X=mS3mgMqILQZdFG?_WuYlL-wOFh>&D1XjD4IO^WuH%$8+Fc zE%;Xp{?+o{RFRGSSQ;7;@9`7y=ZT|F`^h-6=KqT77^w|D_vGw{c?s!tj9tfG*Ja1o z)G_AN2=*a0f*D))p$W&XW$d%NoMZ_$>)OF%-^-a9G}?{8pS zV)QK)%E67)2f$YNQFYKR5gM%?V5}i)>(2$xA{-RCQT%+)gH`zYR%44##DXe#UL!h$ z;M(A|G_}9_zs&7>RNphh@4xul~gG&q-H{wYb{Bqq;B(qRm**PE;@zFS%*x@_FV9(5C9M+27R26}QN$mK|?VB<8yz3@UKm^Zd2*h8MwyuuoHZ_)@3C-_0G zez?WdH7^fzNbd^jBPe+3>a?36ZfP1m``BDd$NQCUqt;ksZ?3ze(_7qb2Nv^S%j<`= z13jgo$rQi6jv+2z4XkO4m}+GCU!ey8|Lsd9KF?+An%Jt(DW;1wxjQj zYY(4U_TuMORy;N5a%07unSJwpqV;25ZJ*FK%=ySo#C@3Um#gg5wdiFw zHb-QNsg>-nh3%d_E4PY5{kHCDnlP_B{bTWlcvEYq$PsiHi^!N#66}FQTK1 z9;Rhs@i$|~*1iS$wqz&r?xc&!D_Oufc?rK`12zomK%cP_pU!{{gP17n7o(tm(7ee9 zByQ&z^sCQbvJO3TUkKaMr{%hX-6D#I4zN?dXX4)u?H!Ttqa54BN7y^~zC<|Q?5EAX zZ=BS@H$>kf-%)1m)%G#It#2LrY`^k-+~1v@5U$UF%@+88P17cMW)%HhweKDM9Xu0V zPkcYvMRLNs%&GNyuaSe3QQrc6Mzq{Ih);>#1l$O1;H$vxx>f&eyRjeQu9gk5<7)&@ zjnte~*s@Ah#A`p+KLbp0Ew2i`^1a$d@sKsrJXK(<2iKkqaqXY%I5}8xsUe!3NDK(} zp1$?>vCGMt$-4B}e6$^%^%31ykNHnlq4+ezXX317xXpywZhP97V;j{%#T*vI7iQn5;7MXXNb=8v>Tvp;<{=zjU7 zA1@-B0j$x7mHzd(7QGr{JOZox}ZW7ddS} zzRXE2^9w}Q=$G?>F^LZ+kKE}5u@(tpEfU09B#5<0q{e?g!TkiXMgm#GV(dJhxEgZ} zXXA-Fn}=tIY_Lbp3ffm>P8iq z=nxI25j}q07w_@+Ir}~>m zhjFCT?y5eyxVWX5b5}II-dXIrzS+CaX*#(Cy))^)KSTM~enGk4?lt^t|1$c0U-Y}! zkn7H0_V)VMo~(kNw~e6a?HafDRl|Sl4CVH`YPdzeH2iD+Lb*k68NqG$D7Wdwn8dsK zCcezK8V#rS19EnXdwj<5Hpi20>1-8j-ERcMM``+SEq=Xk?_%yhE)4!<*shM7Klk%^ zXRve+@yrKm+{)1g@ylt~9*tbJf;_dhPUO1IRLSc{y|#EPDBo=mT&>&>zNx%7;xYG{ z+m!PI;!{pKVz@V-q2o$}^4ZF{tW3F=eL&7TvCz@;xtHSI?pu2e_g8l+cj~LkJ#vcS z);&r6v(?CyZQ9o|k!@Vq3X~ey-eU?<@C0TgOkQ#_wd#wl3;elGA7|RXtC~jz8l{J(}cRXbrk;>O%7C_p9uUb$_v;8iw_!Z@ox>c@(V^VpEYm9-cwa?xb`np zu#jig5zCVxuWr6;1i{}ccm8bUe{h(3DU5YCV>LXa{Ke#aUIE^}ebfjV-{;x0c;`jx za~)*-e^>5vSE``#9O{PMpn{+N8+gRKdA)}85e}Xuj%Z;ivDYUVPSt10x810mS3l_W zI*L^A^}9u;H=MGu$}Q_Kf@_ar5B{YJ3Vr0ivyTMN{njwAd;+`n<v<|x-AK&O2Zu2k5QruS=t#%Gjs-|H_2&(srFF+u0Y zyFXc{g3emTnXcTtiAHei7Y%H>HD&{RbjwV)>OW11BlEAWLhdBr`mTRDRNW}Pu*T7$T|)J^rT;)|UeQR& zNoCDPa%NRvJ)L$;@yRV0pY;)RyqNpKRmyEy$=FZEILpe-u8fIZ<&_jCy#rfslvrRt zZW2H76mflP!)MH=VuF+IwcnAk!AWQeIO$${8}t~QysO%9zk31S`vm9qaq{q=i1`J@ zW)Nc??Vpk-afgw6;L;=R`JXjTGOQF5!kLPWPxy9RopWhZ|-o74Q_OHtQSqHy&@!UP>z}!Xcvz|itg&yMb;z!)Y zFB)FFn7+>BeNF!p70l=`%rC@`n3I`vGIOp^VneF!%$@?xZu$~$$z7c#bGWx%v zq?m8sm3FJ;oB5r%KJ7KF9qF!Li%q~D>6it|&!XFnx#ncIk{VKDtZ|Gp#jUy#JOU2- zf6Bc62;v(uLqgi)k zAZp1-UawbJ`Wd&XlspK#1iVeTRlircBKzH-=%*Tw-SxfboF+CEa`I#?%mVm@$9Hxi zPu;;EzrXwxb<4(-}8>!436hpgVg?vyTbtH6zs zHh5zj?%XTVL87!KIA;s{xFPK}jpjSp(?**;-ICUOT8QtUa{<|elu^8yB_>aa848L zHST#kqIow&^Ii{L?dY4A8qjIz%1X{T^vd4GUclFyUzEHK!OuLm5n5Ks9+lzOurkMl zt_3_V*U4c|2gy?Q1Ul4A{#KLF2;g6|BJNhs7Mo2xRk48BXUR1eIM>RU+_R)c?*3Fo zvHWj}O{edi=9ZQ3ARf5gDdt*q-f|lj0AyGIwHAD)rKCy>A| zlpuC2f$uGW?~OVD*m|eb*u<3D+0Xw!7CMBkm5(i;EA**N`wMjZF2`;-LLIrI0!P%h zr8cDhR-&4GK*#P#`ci}HOtJU2R)_c6^P+nNzSN-7_f%DMuQ0sVM6H*;_tIxaW1bw{ zJH@xCL8afzoE6?{924HN$N5r&DxB}k=w5O3-bm()Me}_jy5~gq$_DPGKObEy7d_SI zCwwP;W_10eK6`#N&l%x$+s3bLNeo}~{O4J>kJZ~hERR}hB4nS4bT8^HQk!F@Gh+w- zv&2m5OkQt3*og1GT(w*p);4Y#S6u8YzO*$fzleS>j(!&za@~Kmr`LIVoO18^rQt4qwI;ad9_3uaJLp3}mcQS+fZya!?x&{A zoNvbb&2tPV8`HIn{cDijZr;JzJpV_W!`U*29L*cjBIo<2vZ}S5KLeh3yqy1?m^*rd z>GaF_8w~Gvxhs6r>ts3aW=8X`Sl-be!-q?0w*wFF@j9<9rWrzPAbd2EM>kY5zA5L}5eC57T zhpc}Sur=2N_kNSL$ftJV*9>poh?u*8ysN^yEcaaBbf{(GTy-w;#L?c|E!krc-TQpx zE3OUvt%g@yROHMzg{KtxmyS`vTlb^8_0+gM&tRXkwJlcsB-|hE;A?XhaE7ewYJ8F5 z@9HxBi@SQAg8Ux;>qlz@X7hVDm<;9GLNFa}Ti5BJv>82+Dt|Bqd5xPSZaM&JG1 zKNarqy0(@Fe>Tqy=E=`k!%faJbC(u%`j0}B9(`1~R|5xQvBrm~^{w1rEmeMfPmSod z!3VRc>&JO=??eXX$Jt`YnL~Hx8(Oi8Fy}SYG3wzw_N_xxjC+bR!`__WeB@r=BYgPv zmN(E57v?Vyo||QaxQYz?(!(d(|JQ(R>)`R7B6QEioSXYh@Iku6U2YtQ<-Sp@1=eDs?O^LJgx(MFb$ONqt zU(mWHh+UI*9Nv58o75SNb$jzVng8VIThxf)tYY+&SYdG1UVNCH@RPmhe8|Fc#?`nk zyn4jnWzwXq zh`LGWNJYuGKd+Ry_dd9QP5UR%6}A5h*cP(Jg}}P7AHEu&7;A~waT3H-tqjYUq@&#GjnA926bxB6;5>06ig zN*<*6^nH0p{-3)CU3eG!4_z0V9kQ>`{SbFEslomQ*{kEfNqiYHx4b|2*)Sh1E6@Ky z^04-4NxpU>b6!|C3BCUMU4=e2B>X|-OrCwrkBvX(n4^wWk8b(jEoTsObuzX;Gi|s0 z5FT9g;B0?!(cd}6FHA%Czd>q5N?fhY}%$42Lb~XHY&rSEC)3N6yVmwdn{5^)$zclN>iDV~r4pw%%w$1aa*?)m$Wp|LUYOtFdC)j`U z58*%T^)Mfq_^ZMi)O8xaB;F@HE1X?w=?%x33lhU{Y+{}EnaTO_zKq{o=<7s&rk0)P zeKV+Bj&8jiye1FJYDs_ivl>4?bpXTHpx&c`#^y$xknK&4sW06l^&SI!9 zzvEN;5mf!P;a1Zi5$-z>5cCKKS9x7|q`;rhjlA>Sf&%TEv!FnuC1j_apk7s1w1&0J-`03E|N=#-YyBgZma>qpQq z7)_nf_TNH#syQor)QbC76E6iU_N(u|a~vCb7R+;=u>#nA#4W{Ws!|nM3$V)!P1bz;^c@c9w(3c-t^XZ>XbF~a9E%86BT{_sPo}}=o#&4mzbl} z_zfymMsJJB31p$sMrtg7pRtDcu9ld0Xlp!ZTAxM+N(SI}3;ry4`uVA`JR3ceI)!(} z^M6@_F|h4+Z&mV+Zvo4`?RJ3eiTBw@;Q>R>pwM`UGfs_f0S0-0gYq(V+_5TDOCxhN zTIb6er^W)$89Y<5A(k4Mpzh0d&Sm<9;k!t0@&*<2aQh#l2h&a4o-QF>G)pPm!l zI~U)F5%#OfjEwGmDUvPEWBgdu%c_L^_{8TK+C+R~9NNpeblpEieA3>5*cbe9WvV4c z?826743VGQd$1*DOxtyzMn0!EY4Oe24bZdCM^}hli#&BLww7_KrD)&x+`oL=aNpmB zE>;{5zPF8>j<+r6dyeuR<^Nsn~{}&)K*i z9c(i`q2tEPl^1u(p7FdTYl_ZgwZM0S_GgrPbD;dnampXZTxCVTpXR=z{uTQ0{UcTI zn{O&7ON`y(Qt&KDySHsI{PTD|+pggd*+}mnaZk>DyLwXcxuVB*qjr|@ZGZW<$CIIdit!S zx8Sm*N+qFqP-!c3_$5O;j(Q8ZR^UHTdI9e+*P#;WO=gh?Q*r6Os9>NmQ z2h{1N#O@KZXO=Z|_vK~!lC!Eb?mzG2?~r;QVQ+)koaIvdti!KXMsW^{hcKhpVW}#B#9I>}EiIKRx6W{RB z)G3@F9Y4YODPPx>%DX*0KhT}<{9GHJAI^)MpU}2;Rjp$()}ZsFV@8iVKjE_%*E;yx z^s}5Fhx6m-o1C9(V-B%hUimMRsU;ivKQZc~&re#PxA2)0pPy7kJwA$AgK@GyP8{EY zjc>uiw_u^`S@;$#>=SW(3vql4(!XBEk^4)r%WXSYL*5$s9@DA6V$}rJ`k2494!NM- z@NPP%)UStcErO4VjwkVBi<01TFS+^HMWg@ao@>2>e8G5ES~bKba^4z_IMG?|J6lm5 z|0ao_MK-qOcb4;PPK+OunCLLZjQ`7Osl`J6967n(^i4e1CUQi#GZ&gLa6Z4U&nNO3 zy5ajLJp23J{!i%2Q4P!B-0S7q93zPIxSF(C4Qfe_{}A+kwoi z=i3{d>4?^Z&xH4WxO?b%x9bL-_aBD$tf?WqO&9vsC4J}pG4^GMo=RL7v1-U^DdJ8w z&u_fQvELE;qs;N&*RhH>C{un9iJ1@M`fl&7w)qCTxzJKt}r>S?GEzukhO$X>-dP{bZDXBf#CNEt`AAl9Dtdg_Ts#J-ZTVw|rJt%KGFOE!u_)$=yhr=1-WRZb;Re)_a%X$aOHD5HGaVGu~%?ij*Jg-M#(yjPKX~tT!>{e_b*}w(c>n#K+$YBH z?ePEL{R4)3&#S-(j`X~$f_r|c++Kc&F%+2ntiYTza?8vk&<=Vng3Fy7i=FbxDwvDj z_NyAb{yYetEmP$l4+_}b8?kR`DlkkbNR zJpf-FC4BX$_fC7#dvB}l^>k48FMg!2&M*D2@KZM&Y1vNh&fK}zV>{{!$G-5=zTBSF zls0TrlH-#`=ZZszsQ-HkbwkIK&ol8rkHizFrZ7)Gk66jG4bXLLjwK?iscGI$&P0=q zo`fC1iXR=ApSia&cT>~#G2mJLJ=#Tq~(LvvrT9Mw}QUrEP=z*2kTu zZM{KD2kUXT*X`WEZ|t4#CQf#n5;cLnmGvjL8vAONb0cvSQU@xxv9m|)MSI{$t4LDSu}hS=6-CAIN# zcJqF81L{A`;@UywOCBt+P)7(_r{OW3rR~H&uj#*+o7vps*JGzxCUjTiNpMx{9N3?P z4vQ|24A9jAKLih!`iZu#>K&is+vkm!+`g7mxIX9S9gYdEYynrY+3TGmt!s5j&Q`?F zXM{B+gkK&2U$KE&mqhqFsuvv%e4Pnzyz9XnQ_OTVb%~D+bH%UVpjN`+YT0IUqv=}6+N|4Vik$Wdf?`mw{v8H zck_(=U|t#a`y!Qnm2vSkNUU1!p?f4xD&bv^&N(lpa!cB~HT`8>P4Lxk8cnX(;bQM% z{suQ#x3qV;&dHBqd&tXn2yRW{nL`PwODr`F^fOZ}<+qb_^-qbT&O!3k2FoWxk7f_G zNehjN+lc3Z@nI>FxrFbB769EhpmsLV&2`&nlBzdKQ@a* zcyBly^cyzFf1v&)cC@A7LE|dFWtrf~>W5k$dmmY5!&@cTK&qg*xZ(j@gdg$~bC7IL>wBhL2vbzXZUPg>x2&wSG_#^I zv+|ZVti0tdD>b^;ipsajijs`m^_F$jsF3}CpEEPNvw&~E?(g&aj}ANEInQ~{InQ~{ zInQ~{nVFxsSKboPHojhJ!E-F(>7%@!7sI`lh1cP|a67#8Ei})|o3ZC>7v7(Jkd1lN z=GgnP)7l?zI)!!$-c6_Gv0rt0dmE=bsqi!E26W(=N5S%qf2>4ZU(h?NFdxSJTzYpU z#y5@ceK&VPKe48UeLNww1|iMg(5KOyE^1*P@}t?0IkE2=beOZ*TOF4-t(ec-+iNek zw{EvuLT=^B@92RqfZoF@jXAq+$8&;%!!hQfkHUTUfAkw*6Jwv(bff_rGrZ$xP1B&$ zTvH_c!bZG%G8%r4xgC?pm({eegR{`L%h8X~UYMf;4|O(S{lo59jCmD&F!(Ns2j5wu z^ui4%$j(lPSs4WX%JrIB1IbPLPdSU>S@vus*~>>u4s_Zh4&dD@ zh%>d8$9ve&F0gmpunpfD-;6p%zm2{X;|a!M$Uuj20O`@Z7vtftbk9R$2j(3#_n`bp zc{#-H({rX4{Y&tRA3!*smF!w~%(CKT`u^#dCd03s#YlO9UvxU&-FfV3OuPU(1ixeszZ23^Ll;w9(*@%#eOT99v| zD&{wPkoP~l^s7ArV-)3Y>NoVxIwmWcPc)r|tWG_J{GCEx9)mrEbn!hJCKHUS$a4q! z1;4E5J&ed7-3woV`HCNPf7WMT$-kyV)+YS2_Gu*XITjOvHa<tRb7AM@bzan5hEG&=jDi;8|k!^R%;?-+C6kk)tL z@00uiPs!hb*+uhsdED9TzlXj7>+bUXC*}KZvU`#Zs?fgWzqf0XO!s#93OPQbwLaN> z{0c|AdPUFG)A~Tuo;~<>@ypnsx|s`~iZ+6}IbYuyuIKXX9ed1J<1>XH#GY;X7CXMz zZZAEQY{5L-vu-5jaC~={gVN39j!v6pH-g-N?9ZpzA8E2jTjjLm|jN@z;VsuGbKME%@WQk@)Mu z--P@Ve|*P_u6GfCJ^16gh4|~i--!GZe?9o)`ULUUgTJ0+4*q)Z$90$h{(A7owTS%@ zc;DLULui9$0sM{Nk83N|fN)(;*LkqxaeXJ&g!D!Dh5)V`=(5&Utz zhWH!p4<72T83jG+IK|WRAa=osykg%1=}6n*5SkB@O+nu)Z^AS8O&=Y`J3&UVzSh1P z_5$98V{iW^q)7*VdE*@5L0J3x7Ji7+SVP|ed$ie0-%8Xx*$iI{`mOr~-ZJ}R*e}iA zrsCOX({n+i!S`&w?F=6Xz13qrH4 zF$*#aC)<*RALa0zWM9N@KphxD**nMWzs?I;J{o&*f@a{^ci4_A!5iNe#Is_Wra$5A z`zvpGbr#?Br_1sD8}_c!H`p5|;yJZndCxsFF-O4Ki2=Sd?1^hKe2@18&og?~jbeF< zY5W1g#+!v0%oV~9C_8`SU`S7if2D~HKN$*<1+CSuE#k=nC+&amLWQ2O^ z_5DVJ*t5^e|0MBC>%s58F0*jIy!O$YL4IdiuVp1&gwFZ)RiRDe*%A2B<*LEuJt-&)JosutVuU(#7?qmBA@a-$S6GHX<4lbA5mK9o^y&RE5J|iFcH#<6HDf+;fGoyh-uiIfn1$9^=Aa z8HE0EFYNPokT&`p%KuY(lnHjo0jy6|9>Y69r(x~xT6#7Eeaiss%RETWQ)@!1@#lKE~9==5w#=uA7N8j$(PFfpOW8G3*Tdd^v)t_ zEFnIDIu;9h_C2-Tor<3mKGsgDJSzu!3?jxztxBKvpZ|MmEUo&Vy6aT95psnu2)-}y z*xeE-WfQ*bDyhl1Fc6&z*p68_R zZA&^jHBI8BPjA8;i`E@9n=#jW3O=n%bx3c2N6eVEj+l7F!*liaFufjf`9;;1I+V5) zZqWWBwWsMr!X>|MSD@bwKD*d9$c)-!1KzzN`R~wH;p^36Zf(VLV%lHf=fVC|?XMmh zQ;OJk&o`;lOy3KipdvFqRBxGGL$NYUmMsBKBtZ zP*%dXaO@C#kz9nQv$L>MF*$ryxz@h%ND$Gm@Vv)@5#Gnr=QKxY9KAp5 zjAu!oQ2QOZI;0=c6mlAQ!#eY)8%-X=D4Oe@_R(%E|J4)H=V$x(OYlA@Ymn#e&L8c^ zZsR?j$NSpvUme8wf3Xq!?ndFeulT+tmHF=*Y3{D~@%>_>)?-Kq-!D(#TOcRw#~x$( zXK`C7OcnQrNAbMTF1)iq&Xe^~4aGhB>!I&__oh9{dkoWw-@hzI%(L$}ZEZ55zg+pP zHKtL=$2@TWZGR8uOW#2EV1JK1MPv0j->Gu0XBRNXP}Y>r(g$Ho(?MU9Z#qhSYKq5T zW_=L8x7SNQg#O9*T}P=MNMoC#+uXC=^&fkeO!k2W6ZRxV*{co?^BmUmO|LX_;mxpT z(LdQwH^+uY=3u|pO0H?gTb!pk65m>WE7o&=2G;7PW35iWUjJs!^HzWOPnvNbc|JUf zvy{%o^8oVwHvG~a1MJhneqXNX6^uJrPigx0C$4E;2WNlO5REks-Xj?CY@439w+OKo z>>Kt>$9($Zfp~`eKcM@W?5AkE33ZZwjP@U5{tLSp?^0`e1!D{04TexW^BwA$OJ!)6 z%7A{<{%d=Ge;K}(%Fy|B|G+Y|OJ(S4$9;7f%0}_s+v6}ghexp2v8!5bg5ZQ*12m1|2KAR37zj4!MARj7AKW=Gq< zKF-#k1L|Iq&(UM;2!ni>?BeA5m%~oBABX>og-i87Jl|sVaP;_FpZ4V0%<_)dyNTBeO#Yt3k;tPY|E6~M zVCJICFAl)EHQGC#u{pX+fcytcvdn`&5YI)0)3Z_Z%@*(@*;x)A!1K}A1H9sZwW;(N z+9LXb=u_wu@Jz)>9gjZ2zlQ{NENf5KVb8>>L&&Fol6}2V8-7s7hesOm{G$%(nb43UYP$-FX;*D7thZhV0()_EbOtNNY&Y~9gnC#ns+d#Tz?Gvys%yi`;mOxMRAq-U5Py>0?ML+KOg%{_8PI@1ZCpz4F4W_h9=B&I+^oyyoF~ITCDbybA=|{ zr*-FWtp6>48|xII9o{GV)^)La#!!sQ&G7Hf!~FiB)pHs?z?yXU;ajXtcO16b@7MIV z|1?n3wBi-?_j|l#H+Yscdt;t&?jp?A6pvlo#hzg}oz69_*lV>PKY;fO)c2u0*-H+Z zn)Hp}n+E>S0XO{lr~~HvpnXDbp^tz+D25}SBlI8ZmPZE~P{#-013G98UkH1?BNb!b zx9E%U{8iT>JcEyTc=u#X;~@AVrXyYsceMQw;(UX3O3Z6k?!|h}F&e*h9<-6B6>mWf zb71%U?A1&&Ko+O*E{46>j|BhL9b}iBf?Wc?i(W_T0@xq^4XazK*O>Za=!Y<0V)Fw% z>4wkmjCy0fWlP_M))+l(ccufq}_%+7m3E5rY>oXu@j9>Q-n1tuVP`})y@UCV2@@V*eG_&x$ zXegeoMfhWH@lBOq@}7HFLKcT$BcMIdGmQ6Oo%g#h=^fVk<+J*7%V%P*<{t-fG5V8U z>`xB$XsIu@hH08%bJq*-*<*f>^p6Uf4$E>K7SXWpYL&ppgq3pL^KUv#tvx=qW*}LUyHKu;+Hp1!CY%L?!gA&@Lkw-D4&DWexcXh#vv~(^c@TS>@H{a!?m8Z%_Al*CE-$u>g|)FxoqU)1m1fbir=Y}%RunMtRGxaw{Vd7C<71>TyW*HK>)j8SbnCxlGX*L;_2a@oA!E6kemGP{$B zksCQBnwx_1z7D0KHn0ihRdg#7?a7YHg`yN)pCaU? zNRs;RXeQNVHFop3TjwvR7-vCSu`p$tSL=kjIV%^S&Dp5dUqN1N$m2|$X*hdn>lt#V zr0!hg_Fh&~XsdOXx~fru4*6bTnFD-gWk+)ua=2^pi_gJucKkwZIhG4ww^3E?npbVB zKt5I>9FKi+%W&R+Q#q*JMWG)8<$^K?q{h0ono?J7xkD@|bBkq_ZkKekysV zh+D&RV%B9Mx@KpEt*jF4s-2a!72>#wqKG&(rDYW&jxxj*Z8f4}QKcvrFG9b?GATC& zXPw>Ybkv9ywz{$kM5dO#5CxHg(Wh2Ujph=-uN1#wzz#8TEwTU zpZEK5|IIf){PJhF*lm@SE;o8=du?@1*#c+zBGG2QrM9fvDWb}qbx&Q@e8anst%$n+ z(7P2ikuOa8?Au+J%=~g+`oFH4Jm#U*!>|2A(6M>1&3k@DR^@-HpPF?l^XkxRZhu%; zx_bEXPoBH6^}S0jx-0gz1Bj$L(OqqW{wC73&Fx}Zi!o|?G{7B*Z1(wLG5(;Kc4sE*of76$qBEaTZY!%8EiNoYEmALv z(M~L~)nH^`18Y&av&1bfRtBS*MU`$_-EGy>vPEa5104YD1!{)=!{!#RnK65cx$w%V zQ>IM1vM_H}vRGXg5s@yIb`_>?Bvb!I|Nn^3YS!1t;3ZU)9ji!#%;lv1I$N1uyAlBA66%+TOb--`5 z26o&?GbK0Bw!|%8eI344BtZ0xZ+|lAwj(DB8E?nD?t1d zxlEmP;(w#Q&tk|))_XnjUWD{KI49twgLI9?idYxQD~I0?9D`HAkKr1x3-RG6a6JyE za!}g~DfP#v@ayD25x>NL$wMNy5#^sifY&}u98AF z&jm3KibLnl2Sn~FXZ8GY=T$TbhQ$TTv$mqPoQA_Hr)_>s+~^C{-STCD^{vKAeV>>a z&6O?}IjZj*{8D{a;g=3YuXd1LsPJ51x)(o7ic5M%aY@f8?)s%77YBMO&&kR_yc?MA zl_Ksw{F*QhAAsj0pJgKF z#=W&TS67If7WX&d#Gr@1)mAReRWmV?0>dh;t;ECthHi1WQ?$D{5EOnAqLF11Z@u=PSM#$UUu z(p~K;FC@7V0S+rpqKUdk#9x1$!_c$oG-1nw?mNon;Yv#IcUKB#NF^0+)%Za}2b0r# zD9824Lk`Yx%8YzaKd=PtQ}$EALMkI?2lG=^zzYOB98<^So0HNoD|41RNG1xeIk={| zA03K3RDJx6N;m7_FH|KnVe(0iiCHibL^d(vp1dZS%_A;)%&KuaBsa^Vnnc)^_Cyz$ zCRVx%-K8`|CZAF}c;_SUsW|)N%w|;)H#&E=G{>EdUy{#7r+tp`(gB_`z*F(X;L<0% zs*NI-Yg>egka}d4e2Kddb`b;B@7APS=bzmSVa^7~Z%}?T=S2QvaZbXiV6sU>6>h*a z&2jv;zhbR3yDtIL3)m}|kXP9pH02v3UN`HS?84bIZkX!hS&sPBmw=?WwnUU21-5dk z%SB=_nsj;DJjqSxAU<#@a3_$zv52GOYXh$TOEwzDY&Z+u=wT|xB_|{&m=#^4I)Z2} zROh*rInj7-20nQx8kLWAu7%{?DO3{3%&b{dLwqwcE2}dzXJ0?N@VaYeNPW_U0*n3X8zRa$j|l37Z~rFNi(x&U3G!P(oF9HiSs7S zoH6ABX>(^yhq!(6A1Fxjzh=(t{KCnTrd*kS&7>()8Ooh8*?$LBQ8>@(hNn#=pM$fK zMpSsLFw`utRjWeD{4T3up%X-SC`d;YYSz1wg9G&AWNsx+8yw9}Oki#EXjD>-vWg-Q z_XY5EmMkhH{h9}l%OXsG6$iDGd8ezH^N~o&wdO3G&kVNSsW3&Paj(LOo_^5?@p@OS zSZZ6~L{`xXYoWyRm>ULzf(;H$u^4k^=H|kb0_9y;T4pa59WG}L69r}(G!Dw#62z%Y zG>kz}snb?9&RJ3Hq;@%ub&r^`%O!@NuY275QiyM1S$R1^$d`(d0ZwXo7)1LbJF{SF z+zDL7bADTJ`&RUwz6J!|D|vL#_N0W?f2{mYnhz@Zy%AxRi37teAsdzrSy!myJv%ZS5zb0}%PYiUfN>V818TlOpf~|5Dmv%P>u2W(5~_Lo`Qrz&scL)VG>UQ*4-OI^ZwOB->yk!l@oirrF&*MJDc9g!Mz% z?28^?eGaxNceQVsgWCgs+29v~woGZ#fo!q!f<-?1qBG+k?fpwS+%-4KdBKE()(R9H zA>-eXN{>1C4y2{FDI916%AB};yNHLLq;~N;(o`=eaq$Jw+*Fk5T2yc>e(6x=h-zKD z==6NmdUn6*Mx?Fwn`Vmsy5??*=1}$Qq&&&94|XMDsvtWOxovM^{qt?ip>USstbYr0 zuH7QnhI0$u--9(${2K9FfUq{4yAYOv-)!8Ez;6aH9jH#GUu*ZG4Zb6Cb#I~#VyQq{ zS*2A6C$0PxJ&L@M4fHgANjF&s?yMGzaJ{2jSQvbEBu|BwIt8pTGU_(a2CKp(l@mGc zX31u)t;E_1TiBCU)TC>4B<@93WK+{>bcL--Cc_$CrCSNa_(jlNi}g<$%m~QS0vRQk zYcn$a^1cOWQdyK=#n10Iy;DfkM!pWvQWtEup z(A)>pHW9A71!b<<8mwlp@mOLAvzBWHuQ7<@s&tNXmsL11I+nTFYO5rz3anz2aRQ42 z5+oZH{V|4EWp$(z@iP#=yX?zciKx0V=3C4vispuZ<|qV8^%QZ$-=}nbDRNn#qFsE3 zwxGJdzZGrZkjQQCcE1t#^FM*#0{11$U&NTt7K~s-poPG)pqckJq)D=-^*pM_eZals zQF1ca$mXiRM4nkGw8V1$m3y`nL3S6Gn4Hz+izq5I+-a+Tt>z$^alarerZ1g zwsEmB>a6(yO{qD&1v`YCrfSfDetol;?BFIHK4uV~{dAn{n@=`)bvwr>v0Y zfX@{0RMy9dzg9lQQy7De`E@9}9sV(35och_L>#P*iHO&m99Y|8t9pTR`6Ea>9&t!l zsh|BF<>@iLM%n|%*Pi)8Ki93jyAg-lJGJi!oZaJ8*(%HISd69(Al<{NX%Po;c7w+N z{N90+Y`!e)FR`I5PsH^Wgi%`=%EOm{Uz6n45J!!|?3Y-h$z!=J(}XeF=#a*qe)uIF z8IE6SUnB5~=-dx){H=Qy5)u;e-`6q9v)hVd7j5ZKEUxK@pMv=Fz{HH-BdBA=?htP3 zDhkw-%aV#Pp;}N@?W&}`RMLn=?oHY^An)a|`FnE6;Ry0O6KSgRxugT*{Lhjes_(ZT zeL9r!z2&6HO?K5~(O!T_m5V0Yim~;Cnz*BurO1RXOT5l0^#}Lim*nihFO^kYF-m>; z?qN2CykpL0ch<0(7Yj)cm4p&Z+*a@*`6_&O09%0Ns<%sqccrUx9Cn^y`INHPlMC8c ziR9BP!5#_Bu;7xXL4+CgSU_dd1rnk(s=$H!(M5%1D#`*I$&xw5!SlB{OUWP?Q^sD3u5@%#* zip5xLufkF^CXA(!2%NnC2Jdw6Zox0v;?JN{qW08%?b;+M+-w)5;lOUYvho_3aZb^N z{U=}(e|A+Y!ImRTXi+$uh#7jZ3yW>O#*<(|!<}D=tsN7knYJ>ACd&rXZ)t0ZEO@9X z_xwDm-M@`rYOetVs_-_1Q#rcJjCIZELbRol&)Wgzqdt)iwLYuyHq8hw3+I|XBe)$n z%h661n|`Y>g4+(Ot&K+*?yGHXH_{*-r&Bs0T=@_=u3a1_GTopBGzsP93n~&4OQC~_wZ&+fwg0otl(hZOKF)#tO_lS?o#V_2NeRg*tQ&{6pqvL$ z&SIoTC)s%lF2gmAp^EI4U)(|+)weFL!2lq#Em<%rv7+R3+(uz^P`#9n8o?D|4I(ph zDs>lV6j<#Qi)JHMF74xTI;K^)CpqAoa3XLa?XJSAzYRM-9lkuw2BTr%<%={`Y01)z zj`~3AZ|J1@uSZ!{;Jgp#Mw}5-qj6UXqwws3Be*;`=bSU-6^X(dX8x~A*g4N;UnGs; z8S^C{`DMrlZUoo95MhhZesR)or~FIT=R2Dhplu-j7Vsfj<6?gtBkof;{Zg26t^Dqn z@2kVq=_zz^7w^CF^@Ogfn#7XYO17Jsw6}kyWcO}{EYaQh4yv2=6E3Q5F4`RTWh$_H zW}V8@$QRY``^X55>xG5a{BJhr1!f4t;F9)m(cGQ-M+KAqtMOPFthcmz}vP&!hU^yOU6{hP;swDd`41GKG=`R6OFMkNX{Zx4?K;Ed|LyBb?Wl3pe zmgKUulrkE%YBOq+(rPWqwP`6>+ql(PVo5GZOBqp^kbsUzDeD`EPko$%hhYGuu}Hx& zz?80nV}YqJQ}9Y)%Fkli-vSdaaIn05)I{vKzwxF_9E|Z*j~2&@Q!vf9l{iH|@BJ{I#({UVSW+2>ea|zpc%M{IZzC8RL0wOwO zg~^KKMRu2R;*y0?n^xMj5=OLiLJYn`2_t@VO^0%i=!V<^{~PKh8|Oq^N8+4-la8_Y z9f>nd#v*>rI14~4;+!nsC)%O79)~jw?R$!RKL)=RoRe^NE+65up{xzCM{(}MJ=Q58 z{@gqK;VG*|aEEbHxMClxTo%4(FJfyXKUX^nLVhRZpmJ>lzyBRKQ_md1WMT%x%g9e8 z(!LYIrgn~19Ge~Md?MEJm{Ey)t)L+t+cXU_#BTy<37hN8W^-~ zT5_5tEhQ~AEiElQEhBAwx;Z^5JvrTyo|2xLo|c}To{>I2!<>x(fcuWLI{xlbI;B1Gog~9k~yo2YgllyY@_@)r|)hQkK_YD)? zbp3Qk3}}}Auyw_alPbo259Q^D|KSbCzcVWTz3%BxPyTZGKQ*%=Iey{;2|*8isX3D| zpl@QEJLdSQ4?Z>?(eD0q+j~1Nx!tl^GjjMpXF`trl7#g)uKf7*>c>7gyfSe>|Gjx% z%&)4v;)A}2A2?8X%ZnqomF)dUD0-&Heb-=H6UasCvybI#B29H~F@ z@5+yBiy@ z&D_RX_~=m11vshA_DWn1?9G^7 zm_1|qjQrV%qr_h<$5-%Mz%=hv@Nc-Lu}Q%KD!D&!uVq2O6EM3VuR&o=ZE+lALB$(Q ztE4rU9mS3I@wpW|&MFf%A8ZQ&A1bz*jgQYFnU9jcVC0YZDmbJY?$Zrd1IMc97XnkA zDe)VCsk{m<0anW+7dToK-WOP%eyEJ`y4L^G16ll?hj7kA)9ujGp-NGDMgZQMYT6jU zo)RFt39b|=g#0kfQ%<+AeohZIo~(;zvez$??1q*cX^l<661~KYafa&$W(e6Lco=~J zE(dYR4!Rk?RBv@Jjo=#3bDCcnfsdj2>Ecw^=Zkxx;nrSwhT$GYgWq*1qm-}z!XV}I z#KH6^xK$cEA3{e>^GF3h0ZcZSyvtH@$kJ0@aAb+M;^8cWZA9El@T<)4q}9sq&&-KM zGqK1eKQjkvzYk^2;SpT^XBgjGF+W=jiz-tT7n|Zuw~4pK#hFIOn{K>`(SJF0@MW40 z1|NI#w|!l7bWDo?Pqw_k)5x1{$-)}^lwKP4mmh~(hv7t`+C35Hiol0 zZ(sB0;VpN^cOGYW`Gz@3aRpa@JgxI2!!NzN`Oo)mz2y;GXD7q|xa<3vh0z#X<9*!TQ{ogoZg_x{T_E$W}O>@S@W45wfF+f`|6!`}KwXB5M;*5_onzI$-Z zvCdeA-^pBd=|5Ju4{>MW89ur0jdkyRa7W{iGbs#zvvtg%^`?{`QqN>De9w!iV}6^L z@nYVYY=$RXzW1Xq_cu4pKa-~+lruc?$G5-mbbS4vAI`WL-cj#;cFUh%ddbwagyFlc zSW>PlEM9qOR|CVd&2Od@d3U~hdDm)&=Zt*yzSS#cK6pddT897j$I(@>3xE02-L;Y7 zdv|=ZDtQh2M=$#*He}K*WF#)8J<6&?;9N_jCX$7 zwUgnOlaicsF5ULtFI~GC-g^7umc3tJ{!oN>AH(_yW5?_cD`-pb?q~Sp`)kS`ij94C zhW7}=p?~L=|Mb$zGj?wq!~YuG?|z5zo1K639%p#psytWFzMZQd@}6Wk-g(K_bMbx7 zCT}OhROcLL-T1!O-(!V6wZFaHOI|BFins3hSKXgAY*h&Bz(H#}>c(HbbQtsY;5qgI zhIbdgziw9s8%Z#aEBJ2l`^kU2cQ*5&z`s`i&*wH}d~~3Kt-Qeh7`-GzeA!j^_u(BZx8L1eHQ4bz|LG{coZ%}L{;=VpCo7(q%)1$0G5@yh zi|c}ZD&UteyfE_fMUS`TZ(qnaF#Oh@hi|<9jvMc|pI^=JWj8(8yk~Z5^HzQ>!%dCr zel6HO=7D$kjSL?xY<%c%k4^jHD}EEhm#!ZFS;|`vKh?=^Ww_w6^-orB*n4`QK;A3( z0ABxR{_Ho7ypkmBWccez(LW9PPv@#!VK>81)fIgF@cZJv5@8?1U(Oz}_&+xcT)$M< z&v2%B__`x6HGciDaD?Fpn~oOD{_vA6FAHr9XJtRV>60Z7|JEWLXE-c-)6==R3tsz| zaFXG{8?7(@aL;ph={21U$2VNJIqZkwEuuz?(HhUACf)bXZ#IQJJV8U&1IIlQvhnfX z9uE6&;hY*WaayWq91@TQ%0U5pO)DiD&p;Z}!cJ z8|U4#OGC48?7Q8udgCL5Ec-vzWHJ2AkfYo0|Ll@SPie9l{$$~ouU5YC;J^B6$-3~b z75Mt}UTsorEv%_!^AU5sw6=U3;ts%hHd~F%PKEXv(4EyDQ`x8r{j=wwS8P;;_PMjt zp4&!M;y-`Z__DD*R+KD6F-wd~60@?zw4~99qr`tfj;~-7q{`-AvYf~!B%47H#rWT`1jo_J!`$3 zyDca@%jEdu#?G|O#FHbmhOdO(06F!Z#{k}V_#FneD&8Lvk8I<~E-e2nyh?tQ!M9JJ z-KFPrH#bQ3c(3)~C|gv>9^_?R5Vs4oBft}GI#%~R;$SW<+ode7b!iAj-9v@MA}|dgV{z6 znX#j3Vo}6pBYrUA&%!V1+-^JvOY5t(zUmc_*UC4d@r8Rb_l;}f8#?&O_(@y*1eBD`q<*TJP$tc;;VQ3MQ;d7yKLgM|7rP9 z8xfh7e(iO)Kl}U(e@kuczw%G_JgV&z+OPlUq?F95(`H;TbC$z-=jyxfefiC|cklhj z!Gf1x84_hMnt~$+rH#+r^335+g3{OAx5Z$ZFtMcU-uwHx3g7tthZ~Adc6w*$Z+JK% zaa7!#M;af0a?{gW{`~6B-TL5=0Yft{pL+G?r}w?rXt-o>^raIo|MvI~-aUJ@V$7u@ z<187OIalQ7&7O1Z+#3pRF0wmI=GWBScKe;1o_%54u9oLtsC0e)h3Dqz#X604oTfy> zCnnS{8>&g_8>Nj68m1eo%hraDsee`C1YEnX$rUwl)86zi59j~z)gUkbU zBQ!&Fyfs66r7lrxG6Wf{;wWuMP?{!FH`t&JG33oixAd_X5{xGONX<~AP~UP*m?k~m zIA-ABkx>zYf@UJA>^_$mO!^$-sG!>5$rH!uC+JN2tM$AtOrs0F-Y5($9+qP?)o;Ez zdTOvq-zPj%Z_-CZ#cK!E|24}oJ0vH_G;QjT9OLXhGYqEsm!m^X`e~-2n&~s}aT}yM z-e6jqc8OtvX6PKgZ*rgI50}&i*YCbF*WRbW95&E&@58!f(>MGz^NzjC#v8_H3-lvR z(@b%?@TJ=_>-XO1yiz;f(9cSmv#!I~aB#HgiEo!$`tn2dp<3h8)qm2?*Y(i^8N%)@ zs{d8LbbIdfAa_>%X;Y1{YQVHxBSIoVt_!-Pe&y2XniZ4#4rs_5uGiNe7^|B&g0C8< z8LSnST8H<`)bUGO#?&7itL2xr*8e;@S8LJ=%ll>LURM8BmY&zn(G5uvmWIY_9U<46 z>YvXT+9zHcWDr92^&6HS*7no%(Ja&!>O-`A-wGgs^Z!`q;Gereo5;C|?SSY?{9H!~tKRjq4KS&$NU!oao7{W&h!v~6* zv6^wg3A|aGBqZ}sYo8IG)jntZRrpPJM(EObgZ^B%=&rk;Fkd(KuGMRzJ`e4CW$tgC z35k~%+*J5=!`=7XcmFegdG)nDd*A*07j55oIW21d>6sHQn{mZW4fh~$`>U_*{rmeL zw0*<*n#TlcA2&Ok4fj3#$h+@<(5K(%%n4IxTz6x^&4mu<-S<6%D0|-hvhAA_efmwE z;c(VBytwoAHx3*+@#FFpcWv7I`Wt)R`QX#fa@POty}j>$Fk|Md>#o1K@K5*L`qu}#h0POD_v1T3vc`5^DkWW+RlN4h7F%Keda7`B!9g9 zr9Jx(969mhsp^`0-L(&nOh|nCg;(Bq=YvCEZs4rz)|>Ag{{9Ca?SJ1pbJh(v8jO9z zMkRj#L!~SIvdbq=U31^;d9}^&wtRT_lW)7coLCsW>`U#kY~v8EzTeWVq4m${h8veg zX)ZDH+C*)N)}Y}HdP6@`Uf=$PIR=e3$`qtAY780y4xtdOP7|!>LkH+)8ip9IGYI-Y zA$i&8qKj%P@}BE%Ww^G$!^Nry0?AMBn<=+GQIC z1`k-ZR+p%o07Z)os((G&9a4XA@X|0{{Z~OhJ*r6$T3QfMzr$Gn`G5%;lRm>Z%^0G0 z2M^QSpuIk*etBe+X<$&Uw*F52bDKg2X_Fq;F8y?*Aw;LE-yF8|lz|t==n;Ciw*Ga^ z5KZ4cJvw|E;QV`34%`*Z)~Ig508RcxHKw&d1v@YZk_s%8*^8CT?i2NQ;)gz-R1Dnt1k9v`33@Vt?~nimWq#$sLw3O39T zhJYW>r-$-LQ5Vd|2Jt2MGCMLQTq0;SVcI^p)bsHAYB+6_W~eYsunN4v$P2+iJk*@8 z6{7hC8m$n->ouPt1IVp`I0{C+N#M=HleA`&Rx>gvL=d%tJ_7-W1br5S^%}kpZ=l39 z!d@%KzdeG}+|3t>oW4xpw7f|a@&xpU$oD0Jj$bDX?%#(WX}lzu=i@bIlnhyfMKA@D z7laU$E0MRL_yWG4!1H4SBmX^#jfZlCg@vK&_^pL1HHEEK-*T7$S2fyu~8f3>`h3*v=Syh*F&*C2f@FPh@? ztnT!JCIMBz86YP9nt{j~c-*Q7d(;B-j}qcJ)PIUjrx}FO>icpb8V!d&f#WaNUJY$R z*%O38oKB-R8U@2J?OF|&u1z-bq5MD{-xr+wF|IlX--tMuY4Jiwq*r0!it0~rBwTht zuaHoWL%Aiewjs5U9zhLJ?bq=JHvmK#+yc@$M*Ru{kc%v_{7Ms z#+#$Qy5c{>zM5%GdHkATwy$QN_=7Efmg}qhM|Rrga39#Nb$ramfNOJ;M@38IVwbuOmqrQ3@BO#i5|F0*8j#&pg*hVaC}Ar%*ka<3`Zw>YyOOMHPBjvb``=xo@Fpu=y_ze7#(yxN-@5H$pC$%Cv4LE6kEFJu<*I?b4 z=ZE0IL%K)n_iLX$bKY#u4rP1j z^AVhp(&de$gtJ4M=f2te?nfW*m*cDgX;f;LcPoCmf>1Hv zABV-TVnE1eF%SWV6({*1)*?#Q z4ueT{umjOZI6E@Byql;IWQVr!?%tR@6ucqi;XaI&J467HpVKFweg>NI_T;$6q;AmXPU`YT$nhLKMK0Bvn_@eBvS!&we3Iu5#EqKL0N%Mi)+`TMpzF8*ItS_J z)N}L80?BI789~R|KreZn8<^E4YDjtAhxl&9XI^=<&u(qVBou@QR$n8^4rb+p-sexd zxHu_@lQR9nPBB`FuXVWQRS5K9SM|^x*joUh-%j=+Y&_44Nog_^}n-9w)HG~G@Ao>i@w}O5N z-RMp)Q0Dv*Xg*U4`uHpS?O)YC(XPYf)`>O++O?p~1?>r`EY>0=FVufhzb3VgIJ6FH zkkr2Zdst=QZyZ(eu4Rervd zem>}OL3gh9Lt#rmmk+w^?)*%7K888LzDu^cxD9a}h(mG;C>tQ@NDIR25$=}TdqJS= zNOD+(f~pnBf`i;B9zJ2j?Y!#Z^poOQ5if3Lm$yw$ucuyX>L@w2W>dY?A>RI3a9rRT zEws{#~x~$sxc}BbnT$4Cpzf9N|#O4RD44XH3J#Y7*&pV=4-mVVX~~$ z@q{%-c3b51;HQ;b3{?`oZxcbwX~Q1ICyLXj|OSn zsn?YUDu-k+JQOT7FD*<4kSOiz(BV&%@rU$31IF(DInZ6HENAa;R(J1jkV~rKZo`@t zJXeF~?rY&=l6m&%zloQxo^yhUjSnI|wY?VbsK4&~ZL|Y)TR<0wI05qX3y|>>;dm#y z9_kS#%XH@|3-##{So~`N zzj7%*c|H1cHiG2&yL7}M-ONQi?ai=NqCl4gYXN^|K!I>p@TT z5zrR>rU5J4F3@cP9ou<=vImTF%(z$hN@Y6%`ZdK}-U4Y1sOr_WLXsrcsJOwv*T6K6&T4mEvI(4Ak2HNuO zw4^sOtr=mBpgRe=)e>EI+ebiS@S8rMp?vN~oZNYs&q{IpeHJk3(@BJ9BV6IBZVz>S z!y_jcx~5nml$UsHl39;oY zX6nkjyyPDMue@H{ie@{^+dTC&gw?@Z#I;s-d5I6k>3}*QS=J$ZF2d!$GO*p6gbqkv zX}HWjrLu3OIIb?Qi0c3u0g?>&$>CYu!~Lqy#>A7LD+eD(ce;Q!V)Avf-P=nF9+q2! z_;b6*C*xPP6DU6gpxXsHY8wIh_4np%+-Q*L)=PA~_{&fLl^2D0??9Z`sxEJ<6vr=L zn&8TrAi7r29RVH5JRlD$y&|16Mqr!(-71N$D6k(z`bA20NVaqa=(BD?pCRdn`8;Y? z3MDc3)G}$@Yyhu_8tAMvK6P*7ntYl-`P!9K*E*7Ldd zG#T*XS>5XPK>j_ZgVesvSZvIy!`xhIUu(|SzVg5hL~4GF9qGgp@M>KQp9QW_H)@|< z9mJ&!vr_*L+K44Gt$J=&1=+|tM|Io+x?Io|NId;|VRHENA{#RtMMo%(78`fmh*Kro zI{|fX(nL}NS8AUGL3)*eINNTM+c(B@-`J?KPKd4ubh|*;qphHXN?S<*9X{E}odDfd zNv^&4hcx?14gA(qb}-fNF2r*z?ecC50mu%mI&b}MLc6Z&y?&`q!myaJ`)1&IU4?P=kPOe2AXjwWf+Vd80ExF3I zz0?Bbte1eC;CQg!igdCbf^JK44DdT(t1%SHZ^)9Ij)1;&LoaOs-UUVXh)#=#I5vW= z8P@@F61MmVDgAiRWj%bB^o@b(6MX^bOE>!GZE8D%e6fmcL2Zg;zZ&!>KriRR+)ei6 zBJqnJ^rWx55U1f0*kn?D`P-pMX!B(r2~d8HgSPRpE^i&KQO<5-E^IW_kV`rfg-v+v zpqK3(b^l}%8vQ*KJR0a+%$TN-M*=$G4`R=_JHY37qu)0h*uRjFeZHvPSSei(*rP5P1FPQqP3W3_Pi~PlSM<2#%B15C7m_*I(Kh?1XTV= z2ojd3`VM?q$nRG0%6{6n-eNtgj~mrs4e&3KXKZILH!*kw5@rW4!7ZefhcgOBSHv^E zG5(^`(^#nw3&;d}Utbk?wms`#-|AH!tD%Yk@{rocR>WQVoNtY*=NKWZ4HzLZP=;2- zN!jYNlX~|{)b~s;i^@L~-$O*)EppxUYX6!vIVh=FZ2(hywjzE3;#;4GKS^qvdFPn- zX?BB2Ubl%~E_gJ8N8C1y9TJbC^Xh06bhM}!9R;r(oF~9<$%|dylkk(H4=CzQ{u;9m zJX95s6U=Nd^{u&xo;3`%z+a);SVsUabMNwDtB+7=7zP1Sf=+5;wcT!#=$P)U2k-3H zQEyV)?0ueY(!^sRsZz@xT;VtgxW#yqjd2`2Ti)#Qw#fC_tsiPeUXV|+wUsU>JD6k^ zI~@J^+n5Kzr;c*=^y^^l7X?vyc90A7391_`55%hqyu`o5moMd^7ha^qs+daCRU1Cw zvjpc(@LKk(D2D zS`ml(nSgRZ)fM}K^5g*B3D6Zub>4G+XA+J;=>lq);%!8{$d4~x2Ky1O0r4(I2IwZa zkZ9Nw`+YJ9@GX#x;t}44@Ljm3_TJ4tVLKH328y)4T!c7P2QY@nW$&fU`5PP9QaWo9 zr|95?uXj=2n-S*(;*d=gP#1s{-j47Ngj2nB52rZB7}x^{UoVBP;eCcbH4Z?wyG63O zQb1dJ=)!1=K)e3}X;*{RdicWl?f~sp&~EIRUyR`X{8FFO2HL1kAWtnocIYm?N5!oQ z5pb7HQrYa(q-jLQs=Ad!{W6V5W(aWY=jij{M+L9?;PVbh?htsGf_od0h+jSU?fMt$ z4L)k{JE1=>KP^^-L8hKj%QJMU=N9l=-_g78kHSwNe9bw+!!E^K^eo{dOEbdj5x!es z`8}UML6eK&xaU+((#a*@)$yy(2O8jCro3)Mc=m5+58sLKHD?K@c60>cM-bkuVR`M| zUfG5ve|weY^UI-^3K;BXdc;f?t!6Ovkl4j457iB^tc1* zYzgvuk4ydX`DCx5tysP3F`5&XjSe&?*n7@((|FL8gDw|zMYyIuIAAQmR3uCp2@uT2 zKhQ4$eTPKf+uTXm24Si!Rn7|9{fL(p;#Jn>t>>`2Y2dYXGrO65B1eNqAFsDTlF#|- z0Z&HvCT(dR-~caosMotq=5^M#VuBEQ>{5i@p-fxAqqVQs=d%uwojXu=R40c)9}#x$ zI-x#-Ucw#;x&pcmu+3lx`)o6KW#sEzkfk7w6>&r@i&Jzy9n}quA=C-;9D9aIJ{59dV2#`?+e{vox6OVZ}}({vl)0{s#E; zt&z|7cWP{j9IkcTRE9~WqgKSpALv!qu2pt}soXyf=LFM^8)a0cGS?wq_Mmgu579M( zE(dhf9s=seZ#pwSP&4HNbaFkm8dc6Fs0T2zjjoquauT!+e%h))(khu!8lyxg-*(Vu zOX>Hp39Se}jPR=N`J>|ZqCYgQxe+HK5;E%^2bjXwB0LJ=MN+ugXNm#m;M|Vz0))$B z@Oj%Njln&8LWq<2k3)Yk*z4Q3(976h4Hyg9`nzhZ01GS59PqIY@p>brvEdwhk&Ak5 z<0OmK;1My@>utm}=LpzWB~W!M6+`ol9iUwW+Vyh(-Rs<&xh4X(2ukaph}$;I>syOg z)j!SBm2{XRPXVNh@d=o_4)>mOEh!gt`Jjsf-I6{4*`aIr^L7yXVbg)kZzM>&sxesQ zgT*HB%a4b?$n)>>vfE8Y7nudQ=y-aLS~Lb)!M789V=Z29n^b4!v-iuItu&Sg8Zpuu zfHe{81*u+T-?e{kD{S}aKgq5XbX95RmL2734e07XcT%p`bBtY@)ifq|8@wp3{ooOo z;q?-~fIb7Zg1W!!1f3Oh<=yGXkLzo@{&64|bY^svb;Mhe+4=i^lH6JPerkX9;8&Un zn@TFLUw$T)08y3XMUt}w1ar*?q`GVdpKTM+Pf2!D(Yfl9JY?PLlJXLg1RfK;%GzGl zIb?6rbf8>S-GmRtBKhZo&)mu0o_+zpC|N(Z1azgKn~OL!o~ipeD{gH>cq78)xwBd} z`&9x6kcM9}u+hPz6+G&vKrT{!1+1B1VyiUo>|jj`3Zy`3E)bQBK4z*{+V890d+qS0 z&dQMux^19~M0x@G21xz61L0c`zE!H5Ds?$&Tx&ph$_&^OJ$1l8LZjAUl>2I(WVRFW zqOQO=&?8>1ic+=M1s)g+eVQEr$P$!8s1747$k&y&1=UwN^qrZI2`>aSp;`>*xCHrvSTzbnY<1HzAzth3;*O!aESY58-m(7mybU zk4(jRy|?GSSA>Z;GZ3DF@LWlr^?ZOqF6FTRGzB-H{er%GyP$k6L3k0u>HRNUZs>XE zU~Q0c&(Taus~NoN3w(B1KzT^E?Fer{c)p~ke%Ye(pqD<~p}a<b(Y8 zpo_4{cAC0>Q0>XiRqZt(-c^WWMVuZo@#R69@2m%17U<%o{06K&vdO4fwuWdh$3fL_ z0Z07>&;*d=mQ~JoR%eR2x!GbeeSsiVj4O4!t7D zZy$`qCs6+2w7U~PA=>fk+KduMak0gmjMvwuJ4(_^QtTzp^t9BHeO)6d1@FsA8#i_=UU-{qPQ#gsm)s_eElJL>o6Tvq)Qs_| z8cmt1=Pt^Nre^3Rp!E5EAZ9xq$-TJ-4AsgXt^JyIyQgTK2FZe&Pc-xX>ZCIZpHb0YX?k)9HM1u*4DI(Y6XU`kKHdBBvObO;=M z(_xJYUkls_jAbQo7r1&EEA-2ODL)FvtADv>75)?OVPH&AS^Op$EA%e|Q+^fvS74Ht zf_DP5{)^qvbM)SC|M8>OaS#adr||+0zjNt_B>5KgmGH;FRGu)9;bC^}%EP#TJX>V? zTR)NVtAxJ|O!8c%lj6UnN{{OM8{n#uBAC#@bM3(Os`~9OaGW?vdN(x5i=H3M0ZwPs z0yhsh1DK_U@cV#wtME?XDiyzDz$v3eN(=|j{S$cK7?B~u$AOQ;`!T&oYi**)Y&6oR z43v|wbnx5+;2pqZ$58lk87tv;0Jo^<{{(zkg;xV-A%6o9fy(zX@JUtpUxDMY@of(| zybUzxL}0TDCj;jJQ+%Sg%UGeO@2@xz9xI2xDPtv^{Qs*EPU9QJ z?}vIMtb|7ZZvv+Ag2KyWtb~^X?^DHpL&i$@TfqA#MRWK;Y=QeXF4{p~1U(>rSLr3J z(B}a=QvChFbHF*tBDV$vL?49t9$|$(1o$xURyq7~87twFfg3EM1QCBKF!7fTp34D_ zo$S}I8ens(KYRgjqY5tqj!YBratSFvpU7C@cLX>})gF%l&jq~_{x9G)NDswAZUk;1 zI-Yt}`jddysOYBwzmM?#GW{*Un^fTofVZf^9|zu{3f~O;D#8{0`Ve@ZD*Pa@c1kq+ z)&u2-55oLF6|M(M0^EV{5Qflxfz|R^OBnQu z{?SYH2ulZE83H^A`9t@__~Ub7Tn56oLx7|Y*UMO;F92Q*dbqO~{Yu~^z)Jt|B5)+y zn}R0+{+w1rGvVqr!uM+f{fdaEA)hvpbX@C4LMr z^}h-p2~7R1f=2^Wf2`nm;M;+-af9mnIvFeBHvm)rtl*n~sr@Us2>27=8Ms05?~<_+ zeh)CUM+M&poT9>Ofv2eOI^aAN-T+*r!jAw~sc<7OwKs+Tlfcv-6}%ak^j*Qv08{%? z@K#`IPYQkknA)d;Uj(N1px~E)N&gkR1DM*If?oqB{Z{bnz$1aD;0DR(pE6d$>3Jp6 zHwFIyO!}?hpMXjK6?_W#6<`}~5I+(AH^NGI3^26^1&;)#@kqg=fwNRN9(a}tCjwuq z!pXpP6;1`NQsE5XRlrJrVVALzUI{R@M+KJwQ~OhJIWV2B!&BqAHAP{g#3;ax!nT#7uZMKe#w3alkq-avM%Wl3zgC(5eP2rUgDB$z2%z?(@N4=?YA*_|IV$xp zb3sr1w*ymqWc@MlX<%xP=*C!hMw`_Bl<-@DNnbGRvGAS1q%S0P;@1UC`hsql;mxZ0 zAp3C_aQs9Op>*)vo^H4qxbah^es$bGfFD=k_kq>*{UNab_|dx`cnRKzA{`p;kSd(g z?*L9wrT-i7S{3dBZnTPWe7rm<6h1oD_z(|loa7Hr1l}^)kCTB@RQj0;Tnen%2Zb`0 z5)imz;7Wui;0EdY-7;3f*8o%c3ibeRRpAGLn^gEA;J>NxMqstP9s~9tKYFv;rTn+a z`d{{)#9yi3EB+;ww^0s108HsA_50#+DLn<>`)~9=2-hMJ(uXHh>5=^3240;l%2~jC z4|uBzzYF}1D*yX{)%pJb*neO?@{Pn##7%0SRY!D#sFRpG;da}mz^7wFp+ zz*|+}vw*))@xK*#mn!^r;5fu*{So3n3%p+y{sOQS;URK)Kc#S$d_D(0slu(mTD-GL zIt1=0aH0wy1754b{{+rP{uKJ-zz*Q6af8~=zPx{1z$709CjpZ@6r2J~@>g&=uv)(}f&Isi-h_Wj@)?Vp z)SjwosjgG&3Aye0h7FoWqy~b(x>)u zbGQ82RN)-L9V$%pD}dW`L~x^nXU{w~%n%tOd>6uVukz!2fFrN=M6tLquQI5fLV}M(4^y6{B+g0T^14rQf+0r3!7GP0@ z(}2w?JRZ0~g|mRys_^B&YI#lu_8&ib3xAaIw*&(!>FWVtice}q@*VV(l%Eh8Uk^;_ zDe`_8nDVFK&w;6Yv9i9;{f|_>B02sBV9Nj1GM=i+56P<(Se@Vbs&J~WN);yh`+&8D zBDm4Pb8CS^RCpb5lue{S96YxH_$j0>9Rl|V@N+8M2%M)HKb{2MsS4i=tk&;mfcL4w zw*t4S@C(2vRQN^UAy@j-e+jr=h3T1Gb@^Wd_8&ibvrkL;XX8EUX9Y0jAKd|~uf4#O zf5kpB{4C|4^#`EO0Va77ruxq9kjkUf-#x%o9;Nq>EFsyl8Ro-Fq*8kYB5<_31M$0#i+HdmR7A= zwUmrTNeH0`Aq*jeA%r1>5JDJ|yoJUvl>Hvh*L9Bb-1+`~x9|IR-9DeU?t4DZxz2U2 zbIx_WuDxEb+4{5o3Xj)%0hazKGWBi5$y^U@eJ`lvm-GD<&M%UvY>{9GuEep|KX?>3 zCgO18c@JKNllg%>|M}e5#_RA#;?f?8cR4V$jUS8?M!M%aL-7_>|8Tqq$NH1(J)N@6PRz>|JP699uu6O!41kA@G{yP>tFV`6DO2J zgKTP${h!<=bXZ{|I2ErWKX$&!n1xrX@~iPk%G>;VaOx!I`*8e4&JW-`<+XT?@}szF zvde!Q7nM3ciMO)<)IiQ|Tu_IXPI2*XaN_AM-r*pgA5C@fj(D?jXS`eaAl#tb4JS`? zJKg2a#CsXv_I%uq6VGto zgrmy8;xy$$y9PnF@+o+4g{yxgzM6Qu*#6^!Ie47PzZ;j~*y|IH=WTq6%5TKED*v#9 zdESDV?y>$q123N&jlFMQ#!sy=;aJA&xSD+a6U+aFf4qcS8XwY)*9WTp5qKH>G1-+I}SmvXRFTfefm*Gm~DlGHC<}boBzO9#F8UNPT;96|YSBV;Qg3KVunR*1zDP%D>?<ZRvQ_yVEU$jj5?X+ItuUb^S+3MgMN~O-Ct9{z%W~;rRJc zQ-bk?b$#Q!{Hb`a%Aby>{JX#Xf^yvYGFM-v=Y=>?#jnF_a?R@t`tuc>tm3cX>i?Me zK)fE;;5I?n|MGeGm#}?ac`{z1@@L@JRs42|Q~y@V%l${%p`jsLBuK}lm%ID_dyQ?p z8ZRckksnC;)SjVj{8&6>C0=Z7<0W_#<0pk5$oRPtk5>6_7~A~KxP*9Y{!n7C zv5hz3GUD<4Aa*>_&^Dfq%ZXbLkbj=(?sp4tm5R$thb$Gp4lh^n8*qh+KaW?d_(r^5 z#ecwSRs1KsOSv9rRPjHtjkT43Zdd*TFTR5RiEWYKFaFu6ybmWber$iHB+*_RTR-WM zvvJ;)B*iwa$GBp#^BA1J#5o_&zs7ki?s082SW0>6-%ZAlEfTziOBi2mW8(KwxC*y4 zPU=PfW7{6N)w>EOnD`tl<00JQf{Xd*9(#RbkM|nec(tU`zt#`&&s1#d|H#cdAM460S@S28@~)EDp%nYbqFllu1JD&^ta z2rtJnz9oJGmi589%fXS@{9bF~mtvX!)yBK9jGwMp?gx+V7Kx1?>ryQ1L7B;4+nt8d zAF=UI{)s%umh&g;rIf!6%lWo`1Q$&3$d=W9BCoBf4bTrdEq5VszLGnKRO2;~!T zx$;R^>bK>GVcEa+2wZ9;%=gSN@)boX`CZz{1OOMUNQIsP%GzB5#Nq`#+o?JZYvxqq9ZEcv(M z4XXcd$J=g>QoC%7MSKtK2{(R!fa{d+!@HCpz*%Rz{Iyv3-=o-V{C=0$XHuUXZ%6R@ zOUm2h|DM+q(mwn9mQK+~tUWUSq(Aep>_5-=aaF$@--meVEm5;e?iIcEe5UfHe^zk* zB;U@zFH~IWi$A>i@wCEjt8Z$nEcxL0Ew`K4a|G!>Wp8OoBs!ppx+#U=j^WyycV%YRM9CI1a&$^WmH z|D%da{vKt?@0ilOe>!8g)i)iaEcuyU{_!d<^$%8-{IOpCcomoYVr9u+=;dFj;*x)r zvgAMFRll)J- z{Ou|(`ClqazI;D|9zXlbgT#L~)@NnOKheuSNyVl9Vak#}!^@wg;*u}lnP4}`zt_vJ zR&mLHNLli?dHJ8Ixa5DKEcx=KqxyI|V7IZ}C`@l0V(cFIRENpQ9}K zYrOpXRb28PRF?dYz5GvAT=G9xmi)Hdh?o9*fcpjQ<;MKqt-dKyS@QdP`I#y%^&hV+ z`QyC&LKT<%3CfaxwU>Xbic9|W%98(-m;a24Oa2CB$^XjB-=X4?|DCerC-iCFKl@|1 zG5(b$f1sCtoQg~RCn!t)crU+L#U;N)S@N&(@|UT&i+!(oVy}w zniL6c!g{=~Q01k*q9oq)P5By1$m^%uR9x!c=#_s(#ijgf%96js%l}TrCI7$5lHWS5 zdHcdY*k*f_{w8iW$xrq2k5zH0zn`+?pY7$3QgO*2qb&Isg zUWoJT>oJ};JuKzb^PP2gB=J_%D9@ulH4b+W7krM-CeBlbSiDu=&^F!{Oa0dEu|A)P z*lqPqos{KxGH}JMQIo>wBXQbo&d1>*RsRWiopLtT`x}bg#{JDPw`MydHfX%l=L=9_D;l^tDDb4|5H@HoWC+t?_Qfav5b##=6P9f zevz(!-#isde;1Q4^XmfDUKy|Rz2mu5#bvx-t}OYtd-kp3(e#9E#mm-;|^*`NO>Y5h^bApQbGN)4co{DlYl6lqLUWFMp+q zOa3Zl$$uJW+#5Abjs(x*#mdiPJ>E8|@>1U`%2MB#UjElAF8SXoOMaw(^ZMhl+v=NI zDNFw0UVe&-OZ~l-C4Uq?VRWzH1uB*KcNyNOj;{*e!hDmL=@Nfb;%Ytn6z@{`pX0sC zbvWU^sA+N}_y*5c-ienhe~+`zb?c#g&&M_uKL`i+yZXA}6y-y3u5uJtDjz0s>hC}` zay)0?3-JNQb8#8w*SfLz8hkCj(D+?kUL8fUMS}P77Ud7|Zu0GVCSM#-^FTC~E%`0* zLGI}fe!OwGgSem=%lWb{!E(N=C*x~IIZwsX z-!?uSOaEAxW9c93Ie3qHKmNs7`pd>I!O~yWm00@2dLfqMx4sg`e`eh>xC*ycUW#RW z+WhOVo^Ll`x79b@q%7n6aWDT#6_@!?qb&I!dimQ_T=G9tmi$I9|8EtS{C|`szk6o$ z_8*Gf#(JnM`GdXuAu2BQ=O{~lftO#T;*vj6S@NsA{6#7*`Ad`~|9&t3K^2$$hm|G& zO)vj#6_@-i%98)1m%m5FCI44t$xj^Aygxf(x79awQI`C4FMoiFOZ|hCC4ZEcKSsqR zKVMn$=X&|`Rb28fRhIl!UjCgbF8OyWOa6;q{>v&Z`L8NV{&!yfe^p%ae^i$I{f}$j zp9f&K)i)ieEcyMt{7e;>`j1zZ{83*17!{ZNd}YbM7$-dB-tY3LaoDCv@Hp;FJa)gu z`r2e{<8jCHdP&94F}Cs1c-yzt`Bt zt8pXsb>#A8qDh>+?ooczJ7Qw>#?mrA6FBP zGx0@ugUWv#*J8ReR{nFGO#5V6l=@no$oW&p-xse|J|D~e!YwYi(BxYeV5!f#2%nF0 z_<_`at+9Y$MSv&@?+zH*DsG?IbQqvsHiW$@5kp*NM7IEk7Yb2V0pb2&33iP zd>@RnpNN_t@_tyHtDJ*7=ezMY4HpsbK?#{J8;l`aBzQ5K{vdAWbI&26V`1XG@UHc4 zK35vs_(I8lG8&TnD{VV0tgpq=U)Jwp>F*lTp6-2kKRCx@ z;}>A*@7R2&J$GQ~KkF~C^pAaBmBjdz@g?Qu_|~c8m+|)w-c%DMDjV-d!O71?V-j!0 zY04jC-JhRgx79bDnZ|ghzWhkIzt2@%_V+i=R`vaZbDxWvD)|0}lUSeCc<+siRJ;$~ zWBY>{FdA=q!IeKBcfP>Qmn(5Rj`bh;kKt6@iapBuuwAUi%a^!Z`D-lg3Aec5Tf7SY z$CTfHXlNTh089I<55%L@^P;XeVE=LaNA^F|*yaz%(q8LRupE!|NG$EQJ`?NnaTa!4 zebY)gAN0>Mb|~jRU_Fxl=WRGKr(@}VJKpQC^mkEq zaE{uaoZkwsJ@Zst?spa_Oa5(m^h?noN`11PePaySBEe2v@sepDK8S%X4!20q4bP`P z?DaVZFUM_3kp7*9m%bDY)A`8^oT2(}K3=Edm*HyScD$^`onLn4AH!oWbg!qk<4hI* z3J)c|KYNt@C(u#(D&7%i5N~1PS-4Wghu}SG|D||`iciO_Uvcf3jgL_6xeKSN_ z`5}B3`R&dAKf)y{{u$n?_P^h7`a{Lr;Y7;Y{vCiftN8J_R+XQCGizOYC*#q|Ww-Hf7bh984uQN@DALLA4q#LjBR`%mho$S z91b|%R{Tfui;Zo(1k3rio{VLDSx?1s{;a2C8SmERSmu-U94zC-`eH2e(fSfB>Szm?qdbi z;`aLU9p0|uyNyRuUd~qu|IqO%p388``>y_3o-1&sieG|PDPNA)Dlfw8m6zhqoX>EJ z1lN1M+4D-AqVn&+CCc~U`O4L}O8H?dX{1`?^&7(LJJ#!^B+32rb2+@eWBl(n{u@jCV&jAR;S+}Oc@Fm1nz-B_ zUy7xD)-Pe1FI!Fd$Z%c{s`5jz^v7YQ{1sS^_h{qSu^eBfaSzpgx!z=o)%ZNYb2g5u z_%J;GqbP-BZh*!4xFX@z2~1i*W=MD|9718nXB(_T%{bG+1xEXx5n#LetXY}c!!D~ z=(#KIyxr~p5YJJZrs9X=5z0s7BIRT8YUK>PQF)N(!JdcU?J9pb&ivf9?=-wsIoI_zSp%`4(<*!ArPOxfZWbejTsF z_WD_GY|A&`&BPP-BF}|43{->TK4#{sZ`YBJ0C03d!~8axCk?h)C#nvCQW*6Yn;V=a00nE0*g~K9>1w zX#pJDc`>gJnKh zA9x&}_hLR+pNwTZuQBz1gk?Nt7#AN;c|6Y4*MQ}G9BlSCFe?%}AES&f#=5^IW`G?SBDYw?iEt&i&STvFB?%FT)io|0d5Xa0%^=jVIdoigDPXalva? zj>q~9yc{3N59D|njBWf6Ed68s7nc69-iNp1KKww+r<@hq#(QJwFY7+IGq&s57-JjH z$7#gvdbY^e#+P6@f7aJvy&f&YZsYyxSg%KIPUiE)-$a8wX8!eN;gRuQL?Ky^{yBy9 z2G2K6=MTEbcpPaw9?SVkF}_*tPv+C(UVENYae01Rr{EE{~N52w!I1YiVC>J!d?P$GPO^P(q#;JZchFZ5zr&61SH?0PtPjQ`)a$n%xK_n`;&}D_$-VGa6+ay3srS>R;O#2j8@DcW z`|E@CeCvzd#{2!To)4pja($;hdq1%f%l;THvH7+gOZ|2}-h3M0FU5S}vJ+c>wquze zX~uaYnXl^g-^W;vw}Yv#+v$8C75!Oh^3%`Y_pR#tv1VgAzEqR{4A%L3Jr7jJC-eDi ztk2JA&*$S3b^gZTUCPBcad(ux%f{ymJWumH1E;9`Ie3rqe4O!PG*+9`cbVraJzs@K zsQhd3D&-q-S9QK`#zo32ak=s;yh8a-Txwb)&tvY!ZsYTWSdWi+a=l^yB_zr9=3K5f z(m%=Odh|G!{;oCg6VK%Lne5Mwmr5-Aw|)sr`%fWX*7LYre&2}?Gp<(ck@H#WwfA)u zm+QxyUVGnGaVh^j*8TUB=X$(O_3!U^hw|UJ$4^mOCmRRNjjry$7INeJ@5bkcvF^V% zDlY9g9Op7WV*SDModHT z9Z_ zha1Tc`!gyC#y0*DP9h##pUH}h4sGM{So+Jl z6_)W9ZY_hhSdZWK*loPu73=YPBlA=G!_MEWSjO9S3dwrV@jqN2IDb_%SbQs%{)#6q z^Lsm%{yot6kh8cSRo91NJQ|1BpO!%<)gGBI$6|dxGdvH(HR^n4;T(>?h3t?1nJE4> zie!rfrMO&qI$owc8_%b_9Zz@REh>JW=Z8E$f_JO@CvZhWG`4rye~siTKaZuo;T9Kc z#3$nnejx4t!Pv%s!qPtLdaTc919lsqmy!G%ZGMa3FBO;m?J}l$d%Al*6i0uHnkxDG z9-fcDBUHS%=RUZI^V^jgp zDfh?Am5;;gl~44Xb95ie8j zg10GmH_n#(AKJgli{IsW4Q~CHYu^KSm+~XH>)$T^gmJQI|G*2I$Fn@2h_fia-sC@P z4B2>ps^^#SIJLjmakcVhyhr&x;}mneqsBImpYQoX++%Mvws+ZoA>OTAg1hc>@hQeB zl#u@1;l;oAyc=gz-u6%OxX|GaBf(LgQ*n{nUtiA|xJtzb;iasv(jHlVi}03zcphqw z|0%p)#lOPqh=&{RpTm-G{e$N{o`1!ARDL5KXRnW}mtzW;U&ZeEUlrcb6b-^H5?qDj zW53;&pG1OdJ>Tg0X53lj--ff4SK}(>dp$qs`C+_XG@sH@8jLnXV2e0ylH|PpDBf0uT=bOoT1_iaDFSdzlEL`d%haar@S2>PvPy9x9dfh zqR`=hi3Hs}ABtr@hg%%?&f)yEPL_P)XYd1=?`Im@_*q!ypY=Id=4ZII3`S!a&o+KO zmho(TA(r!RU4Z3$SQp_6d@w(d{aalRwYc<}bi<{;e;=S-8K+Uu$gR zkK*aX+nM;M#y0*rmhoU+hnM0(CcoW;&^F!y%lNeJh~<7X+*$^maS3kC59I!IKGyfs zmtwc^d3dbvr=K3e^DgcOvq+NHKR@t%OYWCr;}Z|%^^)ALSuZ}D=V#pi=bHR0RQ+;4 zeix2!?dHdQo*%%OD*gygY~%8uz&Xk_o}c%;5zkls@d~a~ehusXcmunwzG<_RSFbPX zPvUtV?aO9BN`JH;!}~vIk3If(Re3qyAEbWbBc(q$1Lsc+9qxnQeRwX!^VRW{;N{9w zaE%Y4qlRVsf7UadUb^J$*Xz&qL}g}*PR#`|%ND!&`)Zc>yIp1UOXyq!rxPvQymFH_cUynDc{G0J+>f6uM z{}Nu0?ft-RT!C%>9>n6YSjA7mYgBv+-m2m&@NUfMjkW(3yrQFP?xg2j%*P}W3 zN9BugGUG4Y;(|+Xs&XZ+QtR_VtUvF0C6@Vb%U^|M{#!4_GT*GP!!p0Ztz~cneuVge z{6NOf^TsxRBYuUreSZ0av5o(PWqw)L;~ls?Kal!*Obu=0J+aI;>s~lsjfc~XZ9Est ze6&6r%Y3pPg=PF(kHIqjt@Cj?j^hW?o<+tsz68towY~<+__bb!SK}7^K*~R7Y~wFr z8Q<0~VVNJ+wOHnl_3K#1zxA6~#=rI3xNd~=7W^ae2nn+Pzm0AFKUl`Ibz~arkvhNe zm?>no{eo85ZG8VB*4Oj7--hEqlO(yG&*y$e*88Q#Yq;Lac#O4&_j?xb`+HemmeN6z z|0(ZZkp0Kz7x7m|@I0C8>j+c6_c^>Dm+PUlN%ALhzaZm3%;)p#SjK;BJ>hxsr1SU; zE`N{D#vj5mpAMnCJa68OWj+lwZm*6{?l;n~%t!lreugpWQX-h+`C?q6=I^C=+<|UA zsKQmsS9!kH^YvKw|8nfM`leg3?*Cg=T-v`8uTlGZ)$=A?r{ZsW-h%h2_=mW47k50L z;vD5KJ@4@R9o}=1`+UXVGUo4O=Ueb9Ro^Plcj8(VU*q|HyhFv;;zq`IV(e_i1s~z8 zgIxPR!}-c}p1<|H3zw?=A8~3|SKluPhZ;c=UAYSLKiO+z(f&_&~f} zISV%^4>3-T3$K5ddhsgHi*V|}?s%5s<=vdG$7QrP(e&qYc%1ULI9GZ98LS80UHQ(Q z5BA&xuj%3PlRPKmIu$?4b1Lp}h%4V0Z&dBc$9Yi~FTlH%CwQLhc`8m$a^+{@E!1!C zZ|=aEjBndNZ{YG|m;VkPq2hny?JE9{=N2=Y$M?f~RDL_0a=5EM5oakM=((HcLvXIj z?}b+>AL%*O^RalX%Fn=Cln3EP<-wkZdLE7wk8sCx8Xir5+55%WxJ<1dcj1&HUH*M| zIq}$f&h_p+T&4PZFW#(tWI5}#DxYc`yMD30U+=|l_Pi2rr@jNse5l2;-h^9R@H%eI z_>k+DTz~70ZM*@?e6jum%Y3r_3(I`7-iP(~fd;d9{Y|_j2~z*j#y0;Ld~OqT$72~E)~&FdU+cD5u3y&e zv0T5b6S2NtcfxMt_orB2uOAu9`=eRU5_rKX_cN2m@jU1hcmHy*Dlgab6Y*-s>u4&K z*N=A@hx>>G_j!H*r_eroKm7sjitYNe4>zjuA2+ADTjH)MZhp1J{V8wnXEX3>Ro{hp zqw-aF_ff9=wRoM1KZDowcJUWHzvB5dT&MEi!qHN9fBrk(fFpE>jHjfEAh=C=B)(O7 z4qmBzH(sIqHoir<5#OwQ*xVqvN%;)CTzM|88sLs^0j^WW|A3hM-ln}<@fK{)PZLg< z;(YYQj6YTW92}_pN}Q#bPMkM+k`&X4t{II8?Pmj1QzIxOeU z`Wu|1yc5g$vGMP*^tbhHEd6c$GnW3g{sk{r{te4`w(&+RWhW1Wa)K3jLfGTyAaV3{x02je>B9$4m&jrYWQeeQ+b z#{2ECUZ1<>^L;<8k892A(-f62>+u;_#%qqm8DSq8hjm7R&pdyDi`4l325&vijrU!+ zw9L)-P765yIE4yjJsXVkReTa&djk6>F8lu!?;;*G`7JNy{$skUFAc9a-tDiyai%F> z>BX<`ycj1=b?fcpcnkHdiG=(A&6w)g_ZASP771G62I{x#Ute6V z;scCrd$021*LuDl|4e=M{^&U@{S|I}_Q~@rc!P>>!kd)e#(R|C_x!QvPjSLvx4$oO z{4{s{Y;#!<1Sh(92i!>99{(U*jZYv=&VLbJq2kx!UCPhm3gvI{V&%lkx!+Yj9@k_i zQM+us7tixB&m(Yy%0C@T@n1dv zj<>4vf8!oAdd1!kE$44Y73;6^5}bIlYtMB!s=VBIliB|VUVNM9&v2S5Ux!Di`QPpe zet)6jiFlXtfyTDK&-UV@J)e*Fs`BG-{3-5uigAweMaDJec-DIH$2_mcqgDB5@OtGJ z@LuItjBS7I^Wt$=HqUQ~yPoRW+ZIts#h>u}6kegqKZolsN($z;49ow8A7g)1$N$F#hcD)S?F@H(N8?=OV{y512Ch&Z zgjZ1C!KS_p8BzQ}E+z zyp`isDn1vVq~dFE*(g{30pn~l|95)vA3XnrSE=&9;zs30oN}(Ke;m*CE$UHR*9j`DI`ro0kAq3W;2YgPOWyiWNYWBdHL-O}dqM9-b@ zc2&MB&K%>~cL**~?uADbaQ|rfvlv&O=khPYTa~97?>6h*<6it}&(GpURsKa>b-t^= z7H?F3!+5KyKjE6@@s6H5<2qITU|gQ>>OT}OS3b3eo;TrDs{Gq{$Azx`_i>N0&L116n)B7|+UD_|o_pb3RsKlaiu)fs zzR$*;Isf6tXFITr2kQ$wkM~@Rt5p6)c$1pHH{m}q(AAx5Je*kM%2(oN*q=TAhw#&?Js;s3<;b!i$e!fN?}tm2 z+u`R_`v>3`Fqfm)@fP6MRDDbFtIAK~4P1|He{aBYeYSqd^J|{pz^x~{{CDsO3Y^P6+Z&Mp^o=II78Jx3csb| zm*LHLKRQ6h%UWEa@*l(1%1`0!sjfZG;jOB^o%loLjyLeUTR97FR^^A_H&wh8ubbxT zpN?hyx94Xz*8MZri!bne8Lm?0uf(6K{XK?1!*={^#|_x_Z>t-F;CF22Q$M_JrfbhY zyj?j9$1|U7dxzj1luzUb(!Zrx=9`UA_dMJ4T%4!!7vLVVT=|7q?#FC>i#=cCc^OVs z`8VN=xvu=JxKxe5HF%TCe*m|h;@_~D*Ya2ow(%O8VlmHXjc$^&s5wf{oAhW@eT zOK<{lJHD1<=|3A^>G=-Ncj3fKUH*M|gYrXoukt!vUg`3m#Osxx#k-YX#PfL`)td&% z`2QZ4s^?vuZszseU#XI+7%J=XK^ z{dfdFkoMhcY~$5fo~Kzqgyngi^&?oGZ&^QvTj2tJAoXoGw(&2qJdd*e8q4!5>u<3< zzp~zi<@uNO54c+SC%j9!9ycmCV0qqT%m0Dp`IYrwSe{>5@5A!E$~w3ue4b?80?YFw z>;14iueEN2<$0}j0+#2y*8Ai6co093{yEOr#!tYB>h~Mj_(}4m2FagnZ1bn$kBN6Q z@s-9lz6#6pVe30_Yv#N4-MFh--`_U2@h!MJ@i=}U`~Tb6#{a>GsPadx2yNr3II803 z8r%4J_%Ic}!q~#t*=0Dt>~ojc4O@ z6`yQu<5Tef;8@~XTD38Mx%7u8b@&vqbgeyM@uTb$)EYEvv{nN0#9=D!> z<@KrcEG(~wtt+tHFI&&UHOdRH++W-HWmxWyt*fxyA6qZNazAXn1k3%h^)*;tFIX?b zo0M$2kUpSydJcEAItUK`a>+&bL(wbo~K)XhUIy>^%uC*NWQP+E9^G@o-o$G-#g~~ zNbL7Ho8o9^TqG#K^7^iU7Xae#RC)P*U+deN*WV7ijlVC9b^RSxT*~+H%J)@q`F@fN zulzt2m-2a7-w%xOoR4?YA6;pbtPfY>z1%7H}(I92`}yh8aryhC}caXAZ~wEsmfUhDaF-1-XF{>?b!O6T|R zXyuQv^jEmW1)pF&ezs$`@%J*ZKEE5s^L<0~ZyHH5UcOfOa=x0d?9cXp$2*$uzl-OC zafxc*p}0c%FuY1R#W+*;PyfvG;+38k;`o{F`t&f)#`b>sW4u+>zuohfxIx8t-~`Is z@z&u^o^LO5{oM(VBR-1u$#@)$bJhMPNxt%OoUz!IUukT|*B@SdujeM5r^?5#=6Qm0 z8@x@qgRvc7Q@!|1&$IDfRel~$S>oDTiAO45fu+C0EiPD$rN6AN#>u!lKal=;(%8mp zu$&+3=dkpj^$S?~*ZL*=6t?GMx3P`?jHSP=f5CdZ|AyVh-;>08y#I~uCgZ#7UCod8 z5YJKE!2ViONRIDRyiE1anV!$WYgPPQoOpGT*<~ci$GOS{o+o&ogiBQZRGhXn>EHTh z;&SB*&zE?v#LHCv6*%#lq<`yMf-{w`^Ss>iEqI*DUxn-FFMI#~nsK;;xZn*e{b{`! zuNm(AF5au+?_+&_Kg4dUZ`y|S`R&SjCjFZn3D>ikSo)`yLbATqV;SGE^$h0}@_n%E zFSdU0d5SBsv?ofwe7@o{wLcjzjaVP=KF`73&D+}oyN&P5!n(a}R9xym0#~X2?CrS^ zUasQlIN{nPvx`WOiF+uY;Q1ua!*Hs~KNYW0J`=B3&htFRb3U$B`2{%ZI@i7lc%<@V z&t;xx;(V1~fwwAOf_Eri?s<{tCAdN5Ux&+dJS)d8)lbaFKE;E?2$S$rYPl z2S32;_b1%`55*12hj~u%+#9FNb>n9g9=G1rcfRKfai+?@3U5~V*LuDlm#X{?Sk{Md ziwj=FGXJe##xnn{U&S*2tv6wr|JH9|ng7=B;8ploejw{lqp^+ujb(mX|AS?IT1OrX z=cjc%micMj3d{VoZi{7pTDQkCzpN9n%rEOsSmu{?7raLKV7y+r2d-7_iDf?9^1ZOE z2iAw<9OV?8r`#JCDfhwU%6+lS2U}kTUamY4uTee@uU9?+*D7b@t;$334&~vvLHQJM zh5I~Exv_1}9K0XnNm?l9_ikewzZc7Rwywr9UacR(BXAdfAmu+Yw((E!g~Z#Nc>F`5 zZM+qh@oe2zY$VT1+GDrz{f<~)e``x3%|4&fN#)D+HVtP!nG|el5xyR+G7jtH`=>lF z#d+l0`1N?cYTvE6LdEaItCiQ_;AvO>0i3A(2u@Lc0;eh0;B4jR@s1i--^)07#`$%u z+xMmyf7kQ-I8&AX*z>2jM8&_vBc5~n+kq>TzxVu;=X$(e<^PU%yuka{IShF|a036R z+2HCw2{$O8j8n-EH}3VZl(+tm=TV-=;P@9^{)Kp?av@%(T;h3(=Q6xW<xxUyg|iVNi|{$#|>sQJ(vF?u!%Obma%&9&b4xk4GzKdmiR_1YWH2PscUN zXW`awyZX=dobP!oE>-zOo+siJDqiY&8m?CHa=cM_E^bg>;CZ3vD{Y`KRMt<+E^+ z^0_$mBUgVu&QdP$Ji+rMT%z))dY+DDJqowDpd9C8`@HfFV;jE<&r$hnaF+W0_5E1J zlg)n+%XqVX7?&E!{m44(w)&do-_q-a{aQv-f zd*kmn;}t4@i{}q;wTf@UTa`b@t+%=TeT`R9|G}pI_Ul52?Trf(vFzWv6V~Uy3w9fS z{}Jo+-$TWvKL=sG|G}Pz;En9BH6E9Qo3eWTKW)-i*T|aZje+AA{ zUgG&W&o|(5m46Ffue=Jk-tOwZ%kzDnAHbO^{}DV|`3W5T!qr#f`FYP9agNG=73V3x ziPtE-aKqB6);+^nlwf=R%@$+2ygK;b69=MHiPuxzq7w({ZI8Ibf!5x)*<4($b zaA)PdxQlWIK1g{W?y7toK3Mq#+)X(f>-jqryRE)yIM(xbJnOTxH;yD(kMG5DJQ3qv zSlVyh`y$q7l|L0rf5(2`Mfr7D`p4GyE0*K2TbJ0^BCalxH9MaAF5nb^jE z!zC&nUC;fy@@aU5@@!o3lk1Opo+~{s#Oqc5V!V#yNipqvLh|cfeKmN#^7D9`I{saF z^>0bR4hBdZ=j)^=d41d9%Abt$RsIZIij&R$ZpX`1d=t*ZQiEL2e#NU*{LrU3Kgy@z zM&)uW?FqL?FxT?}&zIpXD*sBHve2F1$MF0=TzyaB)++uL?y8*dG_T(qU4BO#Wxj-4 zT+kV(F&_Hx13A9I#x_0#%Y3oU!7{$BPsTF7txv@=zO7HkGQO>Iv5ar)v$2eC>rq(7 zr}Y>tbS(4Dx*W@Vvz~)x zd{|$MWqes*f@OSJS7I4o)(f$WC+jP*jDPE^u#9i(rC7$B^>tXroAnJ?#)I`uSjL0( z3M}Kv`ZlbuCwE}C@%_hGUr*MkxU8oyVLiTH^ZW*0uEyUxc*LJ>Jbr*jD{u4sx#v2( zSml4~c^BTG;y>aMf4lwtg6Av$;d!s;CcHuA$JaD>E4*376YwtOjyPqn+kY3&-8~J_VO3AA|MzOT%ufZ%W7d{B7d(m$WB4F1$V-$@N$Ivmp{XenxW-Q1!|A zJ{#-(kM?{%u2Ah8hxahvs6Mv7EWxQw?s%@lS<1`teC3t+e9B7+S)X2!I8HSF5ii9( zjSqT;=aVWv1lK7~#*M1}GS9O-SKySu&X-7V3Emp#d^yf);k?N6QqR}nGL^p^m$Y={ zSK{0%cYL*Y96sC}-_Lllig$aK{%qyS_w=0X`AEEi@*PZlXW=4M{#?)J;TrPo>(?uA zCjA+1yx$7T`LVtl%lWas7R&juz8=f@v0jchDBptReA)P|SjLa_?YLffHEvM82glQ1 zn|~k9P<{aCD6hrClpn>zl^@5aC_jluD%W5+Uv_`bVL4ycFJL)e)-Pe{f9qO&A3lH| z$oT%**v5as(*M@KVLjg)vD@mK{>FN~cbdxcl@`5%J?8mME|&2h`#v4+kMCr@OMk{u ziM&4e8q4{RJ&KcOMq>RFo4mj1E#;}2r#PaFRcOMlsTS~rwaT7(Z(KMm-;fH>-FGUftUEXCycV*D3e& zJkaxTxIyKgh*R6R`f_l#@+mm6or|A=la4z#XUN@_BDzRaNg%R?)m2NmUtucCEVhI)_8|e;2am{r8=9gN3XU}H+Wxho@q4GSX7R&x~sYI?1`^|~O_TP)Rcm$UHA7#7*%khmi z`J1sE-xlKz75sf;j&G;Q&&4vHlT3WQYOk#K@8OYZethKl6FD9g{{k0vvHcMVzQGMw zyY-^|i`*|Pb7U(!Owu z3x3DaKI=cRw9k4kmiAdUVQHUr+{WhTza@4XpSQvK{I|n)lm1S@qt)>p<2enNsCa*g zceDFvtl(>D&mlp0yv4Xt#V_(a&GQW0qr0nb4o>UgJRg@TUxstk@mJv@ly#j{zFZCCH31)&c{>uHR5snP{vOk*2n*?=UsTQ>YpF+wnOakMuJ~( zqw*iP_D~n!i|dplFE#gmp4;Hf_IPPu2A1}QTU;;@Z&K|aZ*1emro43t*8M*jyRE)y zD%Snqk@ZRXqnr+s^=i7xm;SpJ=l8Vji3B%#z8ROQ_-%OevR=Vrb}Ie-3*Juqf2Mx% z;Fr1nMqPbF@fPI~Sn|UyE;tRpb)EAWSn9X&|6qN*dDw0BP3K~LyyvO79N!$Q_dnnB zrFgGuUzO)YI47x>*<~bH>iIfca=lwGpTX-?{tKR8!WAliH{PxC>peH%B7XmzKntXQ zPke>f%gWc__0(tYH*4@V95wmh;LO8%{oDRso`3Yb2j{E&-#jEYBz6ksPl*zKd|}a9dwoFa_taKl^&|7US@Mo&QgJC?>y>|9#ijf&UisftT*^0k<^NW3 zDSyQ4&5!>m?6&%*RIHExSQVG@=i$sFY=1_Av7X1{5h^|ruQS*?zfApk@!|F7VwErLyVt9)TE(S*9`fpYM8&22CtmsODlX-}^vZv&;!?i- zrsl_!h}~A-)Cue3>7wFNeu!5-N5y6TCwt{jRdFdl%PU`@;!=K|SAKztOZf-9@@rLG z%0KFre_X|-{O4ZzIu)1l-+1MBs<@Qz_(t>o>x|u2-*gbx{nt&!rTj3j{0J47{h#KQ zKSRZ({9Ld6d=;1SmwM$dS8*x-uvdPaic9$?yz)<}xRn3OE5Ad)t35lXoTD^o~QCgMX&tJDlX-J^vds1aVh_+SN?Yum-0z(HSdpP?6&%* zBeCv}qg7nWpM$rk_3%8;7vOCwJ|6E-o`~anyY;jbrzuaz`h1mRx3Rur-M)tJ!}g3L zNzT{BDqq@ruUB8Sic5bz*ML7 z;!=KyS3XC@W&bC8{DL>0AU!mesex6r;fr?A{2fXrYRb0wH>Xm<7#ijh`Uimr| zm-63u<#(#Ml<)X<^Zx6M-NyQgb^mo!aVbB{D?dWTW&fvn<aMKVQYA{H0#` z%T-*;KkSuXr{Yrn39tN9DlX-}^2+Z}aVh_uSN^{$F69q=r+NQ%#cpGL#k&6vRdFeQ zidTN5ip&1b^va*5;!^$+uY9G7OZkOf`72di%0K3nU$5d){%NoLvnnp-zxB%RQgJE& zgIE416_@e{zuUb3dSJKJH}%B2|9Yvolt0}opR3}s|FgaFqf}hVU*?ssQgJE2$Sc1@ z#ijg{Uilgom-5ef-OEo{l4r!)!gsTRr%7sHC}!9tGM*%gI;|PV`V);u;w`j)m+^RA?H@5HNB|NXI(`TH^NM=$|^dEk|^M3gG8fnkfSiT>itBG&M@_ho<7d5dy(!Oyf ze!KWtH{aS)hkTx{$i#3)&e=MSrFf3)HEfsaIk4e??9m$W5L zzCB;xwC8!sDtCU5>OlM+7k>~(XE2BLiaveCG2$L7cTTPOD4 zm=tU^@pC(4=I09Ir?7lqjrD;C(tm2cRABl385`e*<@;l-GrL4$pD!+L5w>SKUVLvf z$Taouz!})K|Ez;JUzbIR2CSKpUQXc(LnQBbMLKW}EugrO+R=FW>l2Ebs3uHO}W3*LwVJ z!1DQYd%g}lIub1384a>b{%Ke~&)8^uDc1A723LF={dYa-+PiuC>yKr;zRmS3KJ1U{ z`$fXv53$>hJa7IA>-GQAbo%2}&X?(*FR^@{tjz2`JA?MU7L9!#UHbQ1oXzzl*~FLj z=liE9Z~HTH5`X_Y*{vS~@zP(o{+s$wI+^<$HC|@n`O5d>O69JnM1oa6MuSSTzw1wJ zetyzVW4!(vm51fA^WUC4nT#=CY!gB>P*!Rd@oejitE{0Nr!^VAwYc^1EKJ)Gk= zKHzNfng69`yuE|WlDw4W|6xcx@clH{*(P<^6eXJ^lx;!x=U{nu=O7Ud{2W z$N8^qk7UETf2cr1Ufd$GyyKaTm_o#Qe6`v8`|XKma2CziiAE$?@f<2ky3 z^UeD~Hk;!u!t(wqyFT27<^6cMrv9(6ydN;f^mp5$=GTLVu)ZFgTFm%g#`m|G`hUdo zeu>p)|C1)rUpMjhm^y^*`3=kWC8e|vy)&Ts-Y+PBuTlE3S z6J``lDGvIC9zSzt(5Ghf~gaWXY?uRUpy!yBV*9O%<%*I4azvCaN?{!X+d&DF!sDN`p+z$QB>To zsCdxX#nXor78cK(*|*auG$?a?dRpItf&B)g7ZvnNo6x_o&!GPwdl^3{t#4sbdcnZ7 z{`~*=!vB3Qv19pPo0Kk1`d^bXC0YKjNdE7CE!EHD|Nkg5&=m>y^?yBqebsUFE$UZT z*l&FLfb@a=1`g^sD7`nepdcR>(BXdIPN}oA*=AiKfg_Fx?6ciRy)z}%cW|of~Up#Tr z)Uh*5rp@5rHcC|k(k2Y-n_kejf8VtJ>1q82#i|P1XGYEcwdeIH{=X)t50r*x^c$Nz zGA}v#tl`Od$+P;UB^S(${ikr+jN(3hCQK>s(H4x#PKO*cwNEST(}#s`($tB4`kWp6uN)``IeyUi!pyXO zv9p^#pkML-QD6VG|D!%xUDL*1JbCsMDwQ>{PoLr$Gy3!yHe<%L8K&NJPVI#LgNic; z7WA7?P>^Zs?Vlby531Y4Qvcg2DNG+QzJEbM;h>D-%>L;EGGevU3yQh1A0YpMd>;6TfsaHw$dnkHb>$6f=vetmiHDc?=M(h?wduX zMy|(2%7+Vw=j&N;$CO{+q<1sL%r*G9S@({slKhdtsc=( z?`jb188gzi3BSeSFYshP7<;mx+}d;Z52KxD%4e=`@858D_ik7>on4VnAV+cqjrX%5 z9C2CLX;}Jp;zhYz`bwr#BEi_jm6g7e_;#KanH6|R4Buym+$3RY`B~=2LsyAI`bpK` zJL|M}UuR+2*yDrHA3KJknBn#Wbd+x&pCT%)BC;%~SCWRVZN*+1`6=S7ljWgr4HG@v}E|Q})`LoEWvCJ9ebu2=!L0w{k}p1DK-m#q}9dq!iE#6sy@~z|Dx0a1!s8y|V zsD{vY7F2XVH{Ds5yGfCOc2C;xI~y=#?<{BtPQAA6$DDlM*`86WY3UpJIE+uov&qh_ z8@taAhtKXOdwVDWhmWJ$ORg81v79L^BE?n0Zjz+A=Q(y+26^E76Cytkjl&ZUZS{P( zy{#U)|IAkLxbV2Jl;{_awvV=wLnLZ?aH8}FkBWoCD@F2*bfM}7s>cBOZReRC_+BNQ z!Lh2b`-Mp7z8aHl=fy#`zquz`2$a8gGUl8CWsRv>CJ{pOCd?X)Zc&$R+Ox0A?2 ztd9cUje@dB<0wI4M&W5s2@ZCT_A?P>{V=w|GPaAd%&n-Xl>sL@7Vhou-rUTkP8j8Z zg@)8YIp^f1?o+i3^&3sKWWo1E!(of zxCo;RC5s+V-wCs8wirF}{JBMCF)?KQvG=1Ck?dVMntWRCn(CMh9~(Vh>|ZbP4{q(I z$=1P8arNWhEwZy}THHBLUaes5F1kRgwH~0mRkcukr_1lZ1N{CY^ZSnsro3-oy;>vP zISELSoU=$v?k6Y~TVpnTyQaukzr$B@z2|`wLGB{gkF*l1?{JVSdKax_((aMhLUCtN za}%Dt%lM{m*F=e?n1bFFrm=%lyU_E?*78ngxioubDD@Z>Q$6o&z%Y+p1u?FS5ycQ2 zL|DN4SrPhiKav|UD7Zl)CwJqd(DuA~m|e|VW~#diBJ6A*9c+!Zi|vEraG0rH<@I;j z-mUt(;bVK*ez7&Wv8npre6*E<$!Z?uUzdA6zIyHA!yg`9d-4hwqk~Z*b>qxWxq&l( z?Cx=rAarB5^jt3wJUe$oKTSgB!m|RaaI;}h@9FNMHPhT(w5Ac=MeFm|Su|AYwwiIX z;aW~uHY(0d@ivtK;_~+1meTN_iK{a#m6xWeliPXjm!6l_D*n1x-zn^*;bBiT6Jiy^ zEMQp4YV460CqWq@FIkBb+q1d0McB#CRo7OU6P)4XGYT$%(g_kVg2zQR&T_YT-M5Ad zt>|v|Xp}tDyL81yDV0fQ+m2FV^=;dk#!B|B?DnSxuwrdu4?__8C#*c#RMG z2VoKgR-C&5yg+U{g_mVRCZKQ834P2&zdJkEo2!|va_M}A)~B_&EUdSOH|$_oxJ8<| zVOVB)9wdIEm1AZtb-VM+nvK$@?6@Xse!Jt-GQX@bl=SJtIP*5YU31L(v}@SuK4r~m z>{Hg9jvi%&@9n$B@TUFCF0da&Khe7n3#?l$-z59b;2nV)3`G_C1mE*Ry9iP*^Pm$}#(3~$R$g&jTOX}uP z8RdTHdx@XnvN^We`haJf``OXvAzM5<+CN~A4?{P~i_%7ROPnA`!+Di%x(-}a9v4Y& z7rs>%Wy}`PHO!<Rm_fCpo-a23sf=du|O5G9~Y=%HrxVL#xIU~ z{pYQV*{%JbQt#UZs*KNAy164hk$5rYsMx|JvBNxza=o|4mvC;;@fn(1bbMy!79F3F zc||8?VqVb+MbF%#<40v~(eWcPw`l(*n7Gg9wJPjz>x!ON)EYkmbBm7Cmw81ec!aq{ zY4y2EZ$_u}?wwn~kcNX|`z9ne4vW0-y*S79J`7!b^P9z*SH?{JyfWhx`4i9V4TCri zEGI-a6y`Rbhf|34%wjxI54AR9m4w&Fk_sUL(477AkA^hwF}Gf zuuvAnW57mvVG+Q0X=^35s+s95Z`TUb?xMAlq`PRXR_HETn-;o@)*6WJqOI+x*Jakf zy(emX59#J4B0zl3af$c6G!DEFOL-8DbF*8!*M~t7lxY$r#9=rAe)D4|scJ?0fu<p#kht*s#z@yxej^~6y;4##KaM)BOx zCR8X3Gbe&8Og+Dznbr|JxRE%+!pia}D^jaS(Q2f6Ud(7`moUUJ-AbM*oFSSL#}7i7 z)*$f;Z#qT0xh=5;hvn`*+-KzA7l6l@<#N27ibF8RD{_)Ju}Zkv%**T;gN&2{g_2xrhdP*nQjl$(#OC>fC^hOBu-ABbhBaS6fwJgP7!ms=M*ug zdQK5@oaYo#*Dzz8Q^XL?IYkU_Jf{e|R^6I&iWs(ec9EK0o>QcIcI!2t(@OX3a@e~@ zRI7<9IY;6I?A*5sKP*#Q%%D-F5E)}WR6N1da%ODlt;1sbD0^m@2Jn%dpL#h4*Cfiu zZkuAO93m9OMG$9}MDo~vI#!@E%0+Hzm01x)nPp+B(v2unuQnqhX~mC1Oo>-5_Qzt$ zk~nnIC@9bYd1adFcqij){Kbf_$L zADv;hQ=xO>Sy{zL5`DN=Wa`^Tw-1$}**oByQC)(WLI`q+F%4ls`~V%=LNg_z@x&$7 zIcLpn++DQ3jXR6hHl@yzPAz0~79|F$y4<^q*8X6fMQej-XUYC;8uASh@7?2yOl!J7 z_20ftIp*Tkt@N&D?#TM#^JqA{$QZkYJE)tLu?q?SY;F|dqZX7grV5Tw5ywOBtG9x9 zpMkP{M-b2Yyw;OG=gqwJs5KL;ieiT571lb5S`%P)n`&zRep}bb%^0%h+DC96Q#{Vzey`SrP$n z5$AqZ+8OahMncrZb@({?K|^0cg&C^;*OhwT$C9mRwLBajBJKN%qpuQerR zACCaetrrsaW#K-kZ@OyIa?}i99>j%R1|orHZsDV+@O_>Ud0vJ;Vc(MC$srp~qLQPD zV5-i?D9YbN40V?GL>;wAdAZpZDL)=j)!82vj;h*UiWy3SO-Ic+hnB z$mM)5Itb-*wZI^}Iv{S*CyB=v)N+Dp>Kv6HEnX)!f^6RttQ{8$*y7onWmoB1|<$9u+s=$Vn*)t4!=soQ95@ z6hS_8s{N*DP3242QKcn~o)w{_^c)KgK8q6v-&yg@RGVLQrrDajYqLVO9i4FQ6(?Sq zj$w@+GaNo-fMjOK8!aKGLUm~%RZigARDP~un0SK7WEWmo24y+3!)hG#+JN482e)=I zPjtDqwX-`qys?iZ{=ie1E&}O-D3inlh2$)qA z6X5Rh)m6xJ2c8m)&#$2Iug%YsuM?ZE`Dh9@ z->7$Q(bp%NttYkG4xJO#-f5kM=U&{i*RVQVCwsf-+^EBeP65cP7;%&vB=ixJ3d_Z; z9ol&mtrP1k3d7ZB64cc78-1O4s`jme?4@^F z?+VJm)Vs8?hSb}6_U1A@q3G;FEjeB{IlE|!JkBmu2~=iBH_MZ`38K9lW2#Fq>lR6t z5P}xuC4hO{e;FQRV|?C%=yZg7X0dI%v}(~jSb?3pN9~&KZaLDex76$~qo-$lYzK(j zjE64vb-fGcyqUdMs;kKC74_)mpFUqteeCQ98ljJBGYg@mnlT6U!)DhNnl*8&&uDDk z*UcO>@0!_A+qS?;h?XpfIX`YuaJFpV_JR~D@yv&6~CPxAx>jtr#K&;~jR zy+pI-)jKuIoi)vUsVX(QrRMT#-AH#!Cl+k>hM(YW&2!c3#6f_Z)v>T39-k26HFh5W zmq%N~`8}mxMX=Z3@2Z%;;qXZv`^WbNs}#wau)zJSRsx8uJsj@sZXVzzKg8~cZ`AN{ zc~QZ>8sZeV&EXKNP5J6568V1Y?_sS^(1QAK2r6o_#ZwfNvjRpjr4hC*FLz2}42#Ug z|Ej=TJ7W!+m2J<(TXoU3p8?X#WI*(+>Avr=D`4O9S53j@uEK2HZKJkU>JT@JP&ByQ z;TeW%fk^BeI2%K*wMJKO%)&FFc2C%v9pFe);@ZQ=DZz>X)WJMeT7D}nT;@5=I;wYP zeC+A&X&$Q3nKyU+O~Tj@LanWk_e$X(44JgEkrRmyRxnk8G(wf9F@dGz1UEe|QE0R_hPHx<{Zq*{aYII4Ujm^qM zRvCc^Y!_&yi`<$`E8oi5^2@EGgB$E4r^r!|rYK5W5X%Lt-0bhxk;P_Bc2P+6)w1mUAUf|TI?6s9eT>cNtPtuOLjK1XK;uH z(W)pDuEf!e-Q8z8wTY3#?7Dz@V0sL50ru+s@R|#(S%&BIbX0S3%0AhTUViH8wb7M} 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 literal 0 HcmV?d00001 diff --git a/integration_tests/src/data_changer.bin b/integration_tests/src/data_changer.bin deleted file mode 100644 index 6a36d52c37bd34dcb6e4b70f7fedc9f49ecff445..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 371256 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