From 516e9a1171f97cdf7834a9b0779497d4b129fd10 Mon Sep 17 00:00:00 2001 From: dovgopoly Date: Sat, 14 Dec 2024 00:45:36 +0200 Subject: [PATCH 1/7] added docs --- .../pages/en/build/smart-contracts/_meta.tsx | 3 + .../en/build/smart-contracts/veiled-coin.mdx | 696 ++++++++++++++++++ 2 files changed, 699 insertions(+) create mode 100644 apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx diff --git a/apps/nextra/pages/en/build/smart-contracts/_meta.tsx b/apps/nextra/pages/en/build/smart-contracts/_meta.tsx index 026258ef6..72fb2b879 100644 --- a/apps/nextra/pages/en/build/smart-contracts/_meta.tsx +++ b/apps/nextra/pages/en/build/smart-contracts/_meta.tsx @@ -32,6 +32,9 @@ export default { "fungible-asset": { title: "Fungible Asset (FA)", }, + "veiled-coin": { + title: "Veiled Coin (VC)", + }, "aptos-coin": { title: "Coin (legacy)", }, diff --git a/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx new file mode 100644 index 000000000..bc6151717 --- /dev/null +++ b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx @@ -0,0 +1,696 @@ +--- +title: "Veiled Coin" +id: "veiled-coin" +--- + +import { Callout } from "nextra/components"; +import { ThemedImage } from "@components/index"; + +# Aptos Veiled Coin (VC) Standard + +The Veiled Coin Standard (also known as "Veiled Coin" or "VC") is a privacy-focused protocol for managing Fungible Assets (FA). +It allows users to perform transactions with hidden FA amounts while keeping sender and recipient addresses publicly visible. + +The standard supports wrapping any FA into corresponding Veiled Coin, enabling seamless integration with existing tokens. + +Operations on Veiled Coin balances (veiled balances), require zero-knowledge proofs (ZKPs) to verify transaction correctness +without revealing hidden amounts and other sensitive data. + + + Interacting directly with Veiled Coin's smart contracts is highly complex. + Developers are encouraged to create external services to manage tasks like generating ZKPs, recovering keys, and decrypting balances. + To assist with this, we've developed a TypeScript SDK, with full documentation available [here](https://). + + + + This documentation explains the contract's operations and offers insights into the protocol core processes. + Cryptographic and math details are explained superficially but more in-depth information can be found [here](https://). + + +## Veiled Coin Store + +For every veiled balance a user registers, they generate a unique key pair: +- An encryption key (EK) stored on-chain. +- A decryption key (DK) kept securely by the user. + +These keys are standalone and should not be confused with the Aptos account's public and private keys. + +Each veiled balance is split into two parts: +- `pending_balance` - accumulates all incoming transactions. +- `actual_balance` - used exclusively for outgoing transactions. + +Both balances are encrypted with the same user's EK, ensuring underlying amounts are not exposed. +The veiled balance can store up to 128-bit amounts, which is the maximum supply of the FA. + + + This separation protects against "front-running" attacks. + Specifically, if there was a single balance, an attacker could revert a user's transaction by sending a small veiled payment, + altering the balance and, consequently, invalidating the user's ZKP. + + +The veiled balance and its associated encryption key are stored in the `VeiledCoinStore` resource. +The `VeiledCoinStore` is instantiated for each veiled coin the user has and managed by the `veiled_coin` module: + +```move filename="veiled_coin.move" +struct VeiledCoinStore has key { + pending_balance: veiled_balance::CompressedVeiledBalance, + actual_balance: veiled_balance::CompressedVeiledBalance, + ek: twisted_elgamal::CompressedPubkey, + // ... +} +``` + +## Veiled Balance + +Veiled balances handle token amounts by splitting them into smaller, encrypted units called chunks. +Each chunk represents a portion of the total value and is encrypted individually using the user’s EK. +This design supports efficient management of balances. + +### Chunks + +The pending balance consists of two chunks that temporarily hold incoming transfers. +It can handle up to 2^16 incoming 64-bit transfers before requiring a rollover to the actual balance. +During this accumulation, the pending balance chunks can grow to 48 bits. + +The actual balance consists of four chunks, supporting up to 128-bit values. +After any operation, except rollover, the actual balance is normalized back to 32 bits per chunk to maintain +efficient decryption. + +The `VeiledBalance` struct from the `veiled_balance` module is used to represent both pending and actual balances: + +```move filename="veiled_coin.move" +struct VeiledBalance has drop { + chunks: vector, +} +``` + +### Encryption and Decryption + +When a balance is encrypted: + +- The total amount is split into 32-bit chunks. +- Each chunk is encrypted individually with the user's EK. + +Decryption involves: + +- Applying the user’s DK to decrypt each chunk. +- Solving a discrete logarithm (DL) problem for each chunk to recover the original values. +- Combining the recovered values to reconstruct the total amount. + +### Normalization + +Normalization ensures chunks are always reduced to manageable sizes (32 bits). +Without normalization, chunks can grow too large, making the decryption process (solving DL) significantly slower or even impractical. +This mechanism is automatically applied to the actual balance after every operation, +so that users can always decrypt their balances, even as balances grow through multiple transactions. + +### Homomorphic Encryption + +Veiled balances utilize homomorphic encryption, allowing encrypted values to be added or subtracted without decryption. +This capability is essential for updating the receiver's pending balance during transfers and for performing rollover +operations, where the pending balance is added to the actual balance. + +## Architecture + +- Add scheme and small description + +## Entry functions + +### Register + +```move filename="veiled_coin.move" +public entry fun register(sender: &signer, token: Object, ek: vector) +``` + +Users must register a `VeiledCoinStore` for each token they intend to transact with. +As part of this process, users are required to generate a key pair (EK and DK) on their end. + +When a `VeiledCoinStore` is first registered, the veiled balance is set to zero, +represented as zero ciphertexts for both the `pending_balance` and `actual_balance`. + + + Although it is recommended to generate a unique key pair for each token to enhance security, + it's not restricted to reuse the same encryption key across multiple tokens if preferred. + + + This operation is expensive as it initializes a new storage and storage fees far exceed execution fees. + However, users call it only once per token. + + +```move filename="register_example.move" +#[test_only] +module veiled_coin_addr::register_example { + /// ... + + fun register(bob: &signer, token: Object) { + let bob_addr = signer::address_of(bob); + + // It's a test-only function, so we don't need to worry about the security of the key pair. + let (_bob_dk, bob_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); + + let bob_ek = twisted_elgamal::pubkey_to_bytes(&bob_ek); + + veiled_coin::register(bob, token, bob_ek); + + print(&utf8(b"Bob's pending balance is a zero ciphertext:")); + print(&veiled_coin::pending_balance(bob_addr, token)); + + print(&utf8(b"Bob's actual balance is a zero ciphertext:")); + print(&veiled_coin::actual_balance(bob_addr, token)); + + print(&utf8(b"Bob's encryption key is set:")); + print(&veiled_coin::encryption_key(bob_addr, token)); + } +} +``` + +### Veil + +```move filename="veiled_coin.move" +public entry fun veil(sender: &signer, token: Object, amount: u64) +``` +```move filename="veiled_coin.move" +public entry fun veil_to(sender: &signer, token: Object, to: address, amount: u64) +``` + +The `veil` and `veil_to` functions bring tokens into the protocol, transferring the passed amount +from primary FA store of the sender to the pending balance of the recipient. + +The amount in this function is publicly visible, as adding new tokens to the protocol requires a normal transfer. +However, tokens within the protocol become obfuscated through veiled transfers, ensuring privacy in subsequent transactions. + + + If you want to have a veiled amount from the beginning, use the `fully_veiled_transfer` function instead. + + +```move filename="veil_example.move" +#[test_only] +module veiled_coin_addr::veil_example { + /// ... + + fun veil(bob: &signer, alice: &signer, token: Object) { + let bob_addr = signer::address_of(bob); + let alice_addr = signer::address_of(alice); + + // It's a test-only function, so we don't need to worry about the security of the keypair. + let (bob_dk, bob_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); + let (alice_dk, alice_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); + + let bob_ek = twisted_elgamal::pubkey_to_bytes(&bob_ek); + let alice_ek = twisted_elgamal::pubkey_to_bytes(&alice_ek); + + veiled_coin::register(bob, token, bob_ek); + veiled_coin::register(alice, token, alice_ek); + + print(&utf8(b"Bob's FA balance before the veil is 500:")); + print(&primary_fungible_store::balance(bob_addr, token)); + + let bob_amount = 100; + let alice_amount = 200; + + // The balance is not veiled yet, because we explicitly pass the amount to the function. + veiled_coin::veil(bob, token, bob_amount); + veiled_coin::veil_to(bob, token, alice_addr, alice_amount); + + print(&utf8(b"Bob's FA balance after the veil is 200:")); + print(&primary_fungible_store::balance(bob_addr, token)); + + print(&utf8(b"Bob's pending balance is not zero:")); + print(&veiled_coin::pending_balance(bob_addr, token)); + + // In real world, we would not be able to see the someone else's balance as it requires + // the knowledge of the decryption key. + // The balance decryption requires solving the discrete logarithm problem, + // so we just check if the passed amount is correct for simplicity. + assert!(veiled_coin::verify_pending_balance(bob_addr, token, &bob_dk, bob_amount)); + + print(&utf8(b"Alice's pending balance is not zero:")); + print(&veiled_coin::pending_balance(alice_addr, token)); + + assert!(veiled_coin::verify_pending_balance(alice_addr, token, &alice_dk, alice_amount)); + } +} +``` + +### Rollover Pending Balance + +```move filename="veiled_coin.move" +public entry fun rollover_pending_balance(sender: &signer, token: Object) +``` + +The `rollover_pending_balance` function "merges" the pending balance into the actual one, resetting the pending balance to zero. +This works because of the [Homomorphic encryption](#homomorphic-encryption) used in the protocol. +Before spending from the pending balance, the user must call this function in a separate transaction. + + +Calling the `rollover_pending_balance` function in a separate transaction is crucial for preventing ["front-running" attacks](#veiled-coin-store). + + +```move filename="rollover_example.move" +#[test_only] +module veiled_coin_addr::rollover_example { + /// ... + + fun rollover(bob: &signer, token: Object) { + let bob_addr = signer::address_of(bob); + + // It's a test-only function, so we don't need to worry about the security of the keypair. + let (bob_dk, bob_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); + + let bob_ek = twisted_elgamal::pubkey_to_bytes(&bob_ek); + + veiled_coin::register(bob, token, bob_ek); + + veiled_coin::veil(bob, token, 100); + + print(&utf8(b"Bob's pending balance is NOT zero:")); + print(&veiled_coin::pending_balance(bob_addr, token)); + + print(&utf8(b"Bob's actual balance is zero:")); + print(&veiled_coin::actual_balance(bob_addr, token)); + + assert!(veiled_coin::verify_pending_balance(bob_addr, token, &bob_dk, 100)); + assert!(veiled_coin::verify_actual_balance(bob_addr, token, &bob_dk, 0)); + + veiled_coin::rollover_pending_balance(bob, token); + + print(&utf8(b"Bob's pending balance is zero:")); + print(&veiled_coin::pending_balance(bob_addr, token)); + + print(&utf8(b"Bob's actual balance is NOT zero:")); + print(&veiled_coin::actual_balance(bob_addr, token)); + + assert!(veiled_coin::verify_pending_balance(bob_addr, token, &bob_dk, 0)); + assert!(veiled_coin::verify_actual_balance(bob_addr, token, &bob_dk, 100)); + } +} +``` + +### Fully Veiled Transfer + +```move filename="veiled_coin.move" +public entry fun fully_veiled_transfer( + sender: &signer, + token: Object, + to: address, + new_balance: vector, + transfer_balance: vector, + auditor_eks: vector, + auditor_balances: vector, + zkrp_new_balance: vector>, + zkrp_transfer_balance: vector>, + sigma_proof: vector) +``` + +The `fully_veiled_transfer` function transfers tokens from the sender's actual balance to the recipient's +pending balance. The sender encrypts the transferred amount using the recipient's encryption key, enabling the recipient's +veiled balance to be updated [homomorphically](#homomorphic-encryption). + +To ensure transparency, the sender also encrypts the transferred amount using the auditors' encryption keys, +allowing the auditors to decrypt and verify the transferred amount. + +Finally, the sender provides their updated normalized actual veiled balance, encrypted with fresh randomness to maintain privacy. + + + Once a user has participated in at least one transfer, their balance becomes "veiled". + This means that neither the transferred amount nor the updated balances of the sender and recipient are visible to external observers. + + +```move filename="transfer_example.move" +#[test_only] +module veiled_coin_addr::transfer_example { + /// ... + + fun transfer(global_auditor: &signer, bob: &signer, alice: &signer, token: Object) { + let bob_addr = signer::address_of(bob); + let alice_addr = signer::address_of(alice); + + // It's a test-only function, so we don't need to worry about the security of the keypair. + let (bob_dk, bob_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); + let (alice_dk, alice_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); + + // Note: If the global auditor is set, we need to include it in the `auditor_eks` vector as the FIRST element. + // It is not implemented in this example, but you can uncomment the code below to set the global auditor and + // include it into the `auditor_eks` list. + // + // let (_global_auditor_dk, global_auditor_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); + // let global_auditor_ek_bytes = twisted_elgamal::pubkey_to_bytes(&global_auditor_ek); + // + // veiled_coin::set_auditor(global_auditor, signer::address_of(global_auditor), global_auditor_ek_bytes); + // + // let (_, global_auditor_ek) = veiled_coin::get_auditor(); + // let auditor_eks = vector![global_auditor_ek.extract()]; + + let (_, auditor_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); + let auditor_eks = vector[auditor_ek]; + + let bob_ek_bytes = twisted_elgamal::pubkey_to_bytes(&bob_ek); + let alice_ek_bytes = twisted_elgamal::pubkey_to_bytes(&alice_ek); + + veiled_coin::register(bob, token, bob_ek_bytes); + veiled_coin::register(alice, token, alice_ek_bytes); + + // Bob's current balance is 300, and he wants to transfer 50 to Alice, whose balance is zero. + let bob_current_amount = 300; + let bob_new_amount = 250; + let transfer_amount = 50; + let alice_current_amount = 0; + let alice_new_amount = 50; + + veiled_coin::veil(bob, token, bob_current_amount); + veiled_coin::rollover_pending_balance(bob, token); + + print(&utf8(b"Bob's actual balance is 300")); + assert!(veiled_coin::verify_actual_balance(bob_addr, token, &bob_dk, (bob_current_amount as u128))); + + print(&utf8(b"Alice's pending balance is zero")); + assert!(veiled_coin::verify_pending_balance(alice_addr, token, &alice_dk, alice_current_amount)); + + let current_balance = veiled_balance::decompress_balance(&veiled_coin::actual_balance(bob_addr, token)); + + let ( + proof, + // New balance is the balance after the transfer encrypted with the sender's encryption key. + // It will be set as the new actual balance for the sender. + new_balance, + // Transfer balance is a transfer amount encrypted with the recipient's encryption key. + // It will be Homomorphically added to the recipient's pending balance. + transfer_balance, + // Auditor balance is the transfer amount encrypted with the auditor's encryption key. + // It won't be stored on-chain, but an auditor can decrypt the transfer amount with its dk. + auditor_balances + ) = veiled_proof::prove_transfer( + &bob_dk, + &bob_ek, + &alice_ek, + transfer_amount, + bob_new_amount, + ¤t_balance, + &auditor_eks, + ); + + let ( + sigma_proof, + zkrp_new_balance, + zkrp_transfer_balance + ) = veiled_proof::serialize_transfer_proof(&proof); + + veiled_coin::fully_veiled_transfer( + bob, + token, + alice_addr, + veiled_balance::balance_to_bytes(&new_balance), + veiled_balance::balance_to_bytes(&transfer_balance), + veiled_coin::serialize_auditor_eks(&auditor_eks), + veiled_coin::serialize_auditor_balances(&auditor_balances), + zkrp_new_balance, + zkrp_transfer_balance, + sigma_proof + ); + + print(&utf8(b"Bob's actual balance is 250")); + assert!(veiled_coin::verify_actual_balance(bob_addr, token, &bob_dk, bob_new_amount)); + + print(&utf8(b"Alice's pending balance is 50")); + assert!(veiled_coin::verify_pending_balance(alice_addr, token, &alice_dk, alice_new_amount)); + } +} +``` + +### Unveil + +```move filename="veiled_coin.move" +public entry fun unveil( + sender: &signer, + token: Object, + amount: u64, + new_balance: vector, + zkrp_new_balance: vector>, + sigma_proof: vector) +``` +```move filename="veiled_coin.move" +public entry fun unveil_to( + sender: &signer, + token: Object, + to: address, + amount: u64, + new_balance: vector, + zkrp_new_balance: vector>, + sigma_proof: vector) +``` + +The `unveil` and `unveil_to` allow a user to withdraw tokens from the protocol, +transferring the passed amount from the actual balance of the sender to the primary FA store of the recipient. +This function enables users to release tokens while not revealing their remaining balances. + + + Attempting to unveil more tokens than available will cause an error. + + +```move filename="unveil_example.move" +#[test_only] +module veiled_coin_addr::unveil_example { + /// ... + + fun unveil(bob: &signer, alice: &signer, token: Object) { + let bob_addr = signer::address_of(bob); + let alice_addr = signer::address_of(alice); + + // It's a test-only function, so we don't need to worry about the security of the keypair. + let (bob_dk, bob_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); + let (_alice_dk, alice_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); + + let bob_ek_bytes = twisted_elgamal::pubkey_to_bytes(&bob_ek); + let alice_ek_bytes = twisted_elgamal::pubkey_to_bytes(&alice_ek); + + veiled_coin::register(bob, token, bob_ek_bytes); + veiled_coin::register(alice, token, alice_ek_bytes); + + let bob_current_amount = 500; + let bob_new_amount = 450; + let transfer_amount = 50; + + // Bob veils all available tokens + veiled_coin::veil(bob, token, (bob_current_amount as u64)); + veiled_coin::rollover_pending_balance(bob, token); + + print(&utf8(b"Alice's FA balance before the unveil is zero:")); + print(&primary_fungible_store::balance(alice_addr, token)); + + print(&utf8(b"Bob's actual balance before the unveil is 500")); + assert!(veiled_coin::verify_actual_balance(bob_addr, token, &bob_dk, bob_current_amount)); + + let current_balance = veiled_balance::decompress_balance(&veiled_coin::actual_balance(bob_addr, token)); + + let (proof, new_balance) = veiled_proof::prove_withdrawal( + &bob_dk, + &bob_ek, + transfer_amount, + bob_new_amount, + ¤t_balance + ); + + let new_balance = veiled_balance::balance_to_bytes(&new_balance); + let (sigma_proof, zkrp_new_balance) = veiled_proof::serialize_withdrawal_proof(&proof); + + veiled_coin::unveil_to(bob, token, alice_addr, transfer_amount, new_balance, zkrp_new_balance, sigma_proof); + + print(&utf8(b"Alice's FA balance after the unveil is 50:")); + print(&primary_fungible_store::balance(alice_addr, token)); + + print(&utf8(b"Bob's actual balance after the veil is 450")); + assert!(veiled_coin::verify_actual_balance(bob_addr, token, &bob_dk, bob_new_amount)); + } +} + +``` + +### Rotate Encryption Key + +```move filename="veiled_coin.move" +public entry fun rotate_encryption_key( + sender: &signer, + token: Object, + new_ek: vector, + new_balance: vector, + zkrp_new_balance: vector>, + sigma_proof: vector) +``` + +```move filename="veiled_coin.move" +public entry fun rollover_pending_balance_and_freeze(sender: &signer, token: Object) +``` + +```move filename="veiled_coin.move" +public entry fun rotate_encryption_key_and_unfreeze( + sender: &signer, + token: Object, + new_ek: vector, + new_veiled_balance: vector, + zkrp_new_balance: vector>, + rotate_proof: vector) +``` + +The `rotate_encryption_key` function modifies the user's EK and re-encrypts the actual balance with the new EK. +This function checks that the pending balance is zero before proceeding, guaranteeing that the user does not lose funds during the rotation. + +To facilitate the rotation process: + +- The pending balance must first be rolled over and frozen by calling `rollover_pending_balance_and_freeze`. +This prevents new transactions from being processed during the key rotation. +- Then the EK can be rotated and unfrozen using `rotate_encryption_key_and_unfreeze`. + + + Calling `rotate_encryption_key` with a non-zero pending balance will cause an error. + + +```move filename="rotate_example.move" +#[test_only] +module veiled_coin_addr::rotate_example { + /// ... + + fun rotate(bob: &signer, token: Object) { + let bob_addr = signer::address_of(bob); + + // It's a test-only function, so we don't need to worry about the security of the keypair. + let (bob_current_dk, bob_current_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); + let (bob_new_dk, bob_new_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); + + let bob_current_ek_bytes = twisted_elgamal::pubkey_to_bytes(&bob_current_ek); + let bob_new_ek_bytes = twisted_elgamal::pubkey_to_bytes(&bob_new_ek); + + let bob_amount = 100; + + veiled_coin::register(bob, token, bob_current_ek_bytes); + veiled_coin::veil(bob, token, (bob_amount as u64)); + + // We need to rollover the pending balance and freeze the token to prevent any new veiled deposits being come. + veiled_coin::rollover_pending_balance_and_freeze(bob, token); + + print(&utf8(b"Bob's encryption key before the rotation:")); + print(&veiled_coin::encryption_key(bob_addr, token)); + + assert!(veiled_coin::verify_actual_balance(bob_addr, token, &bob_current_dk, bob_amount)); + + let current_balance = veiled_balance::decompress_balance(&veiled_coin::actual_balance(bob_addr, token)); + + let (proof, new_balance) = veiled_proof::prove_rotation( + &bob_current_dk, + &bob_new_dk, + &bob_current_ek, + &bob_new_ek, + bob_amount, + ¤t_balance + ); + + let ( + sigma_proof, + zkrp_new_balance + ) = veiled_proof::serialize_rotation_proof(&proof); + + // After rotating the encryption key, we unfreeze the token to allow new veiled deposits. + veiled_coin::rotate_encryption_key_and_unfreeze( + bob, + token, + bob_new_ek_bytes, + veiled_balance::balance_to_bytes(&new_balance), + zkrp_new_balance, + sigma_proof + ); + + print(&utf8(b"Bob's encryption key after the rotation:")); + print(&veiled_coin::encryption_key(bob_addr, token)); + + // Note that here we use the new decryption key to verify the actual balance. + assert!(veiled_coin::verify_actual_balance(bob_addr, token, &bob_new_dk, bob_amount)); + } +} + +``` + +### Normalization + +```move filename="veiled_coin.move" +public entry fun normalize( + sender: &signer, + token: Object, + new_balance: vector, + zkrp_new_balance: vector>, + sigma_proof: vector) +``` + +The `normalize` function ensures that the actual balance is reduced to 32-bit chunks for [efficient decryption](#normalization). +This is necessary only before the `rollover_pending_balance` operation, which requires the actual balance to be normalized beforehand. + +All other functions, such as `unveil` or `fully_veiled_transfer`, handle normalization implicitly, making manual normalization unnecessary in those cases. + + + All functions except `rollover_pending_balance` perform implicit normalization. + + + Attempting calling a `rollover_pending_balance` on an denormalized balance will cause an error. + + +```move filename="normalize_example.move" +#[test_only] +module veiled_coin_addr::normalize_example { + /// ... + + fun normalize(bob: &signer, token: Object) { + let bob_addr = signer::address_of(bob); + + // It's a test-only function, so we don't need to worry about the security of the keypair. + let (bob_dk, bob_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); + + let bob_ek_bytes = twisted_elgamal::pubkey_to_bytes(&bob_ek); + + let bob_amount = 500; + + veiled_coin::register(bob, token, bob_ek_bytes); + veiled_coin::veil(bob, token, (bob_amount as u64)); + + // The rollover function is the only function that requires the actual balance to be normalized + // beforehand and leaves it unnormalized after execution, no matter what the pending balance was. + veiled_coin::rollover_pending_balance(bob, token); + + assert!(!veiled_coin::is_normalized(bob_addr, token)); + + veiled_coin::veil(bob, token, (bob_amount as u64)); + + // Before performing a second rollover, the actual balance must be normalized. + // You will get an error if you try to rollover an unnormalized balance: + // veiled_coin::rollover_pending_balance(bob, token); + + let current_balance = veiled_balance::decompress_balance(&veiled_coin::actual_balance(bob_addr, token)); + + let ( + proof, + new_balance + ) = veiled_proof::prove_normalization( + &bob_dk, + &bob_ek, + bob_amount, + ¤t_balance + ); + + let (sigma_proof, zkrp_new_balance) = veiled_proof::serialize_normalization_proof(&proof); + + veiled_coin::normalize( + bob, + token, + veiled_balance::balance_to_bytes(&new_balance), + zkrp_new_balance, + sigma_proof + ); + + assert!(veiled_coin::is_normalized(bob_addr, token)); + assert!(veiled_coin::verify_actual_balance(bob_addr, token, &bob_dk, bob_amount)); + + // A rollover can be performed once the balance is normalized. + // Note that functions like `unveil` and `fully_veiled_transfer` do not require the actual balance + // to be normalized beforehand, as zk-proofs guarantee that the actual balance is normalize after + // their execution. + veiled_coin::rollover_pending_balance(bob, token); + } +} +``` \ No newline at end of file From a73be591d5c575a09ff3fd95b38fbd1a8ebbd36c Mon Sep 17 00:00:00 2001 From: dovgopoly Date: Sat, 14 Dec 2024 00:57:59 +0200 Subject: [PATCH 2/7] fixes --- .../nextra/pages/en/build/smart-contracts/veiled-coin.mdx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx index bc6151717..0140a50d3 100644 --- a/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx +++ b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx @@ -11,7 +11,8 @@ import { ThemedImage } from "@components/index"; The Veiled Coin Standard (also known as "Veiled Coin" or "VC") is a privacy-focused protocol for managing Fungible Assets (FA). It allows users to perform transactions with hidden FA amounts while keeping sender and recipient addresses publicly visible. -The standard supports wrapping any FA into corresponding Veiled Coin, enabling seamless integration with existing tokens. +The standard allows any FA to be seamlessly wrapped into a corresponding Veiled Coin, ensuring compatibility with existing tokens. +Similar to FA, 64-bit transfers are supported, and balances of up to 128 bits. Operations on Veiled Coin balances (veiled balances), require zero-knowledge proofs (ZKPs) to verify transaction correctness without revealing hidden amounts and other sensitive data. @@ -29,7 +30,7 @@ without revealing hidden amounts and other sensitive data. ## Veiled Coin Store -For every veiled balance a user registers, they generate a unique key pair: +For every veiled coin a user registers, they generate a unique key pair: - An encryption key (EK) stored on-chain. - A decryption key (DK) kept securely by the user. @@ -39,8 +40,7 @@ Each veiled balance is split into two parts: - `pending_balance` - accumulates all incoming transactions. - `actual_balance` - used exclusively for outgoing transactions. -Both balances are encrypted with the same user's EK, ensuring underlying amounts are not exposed. -The veiled balance can store up to 128-bit amounts, which is the maximum supply of the FA. +Both balances are encrypted with the same user's EK, ensuring underlying amounts remain private. This separation protects against "front-running" attacks. From c2f2cfdff3dbd3c16b704ecb50b98cb997c44a04 Mon Sep 17 00:00:00 2001 From: dovgopoly Date: Sat, 14 Dec 2024 00:58:53 +0200 Subject: [PATCH 3/7] fix --- apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx index 0140a50d3..039e46cad 100644 --- a/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx +++ b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx @@ -11,7 +11,7 @@ import { ThemedImage } from "@components/index"; The Veiled Coin Standard (also known as "Veiled Coin" or "VC") is a privacy-focused protocol for managing Fungible Assets (FA). It allows users to perform transactions with hidden FA amounts while keeping sender and recipient addresses publicly visible. -The standard allows any FA to be seamlessly wrapped into a corresponding Veiled Coin, ensuring compatibility with existing tokens. +The standard allows any FA to be wrapped into a corresponding Veiled Coin, ensuring compatibility with existing tokens. Similar to FA, 64-bit transfers are supported, and balances of up to 128 bits. Operations on Veiled Coin balances (veiled balances), require zero-knowledge proofs (ZKPs) to verify transaction correctness From 10564d17431c5b34934e19ed7955d982fb283a8d Mon Sep 17 00:00:00 2001 From: dovgopoly Date: Sat, 14 Dec 2024 01:13:24 +0200 Subject: [PATCH 4/7] fix --- .../en/build/smart-contracts/veiled-coin.mdx | 29 +++++++++---------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx index 039e46cad..4abdc2c04 100644 --- a/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx +++ b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx @@ -62,21 +62,20 @@ struct VeiledCoinStore has key { ## Veiled Balance -Veiled balances handle token amounts by splitting them into smaller, encrypted units called chunks. -Each chunk represents a portion of the total value and is encrypted individually using the user’s EK. -This design supports efficient management of balances. +Veiled balances handle token amounts by splitting them into smaller units called chunks. +Each chunk represents a portion of the total amount and is encrypted individually using the user’s EK. +This design ensures efficient management of balances. ### Chunks -The pending balance consists of two chunks that temporarily hold incoming transfers. -It can handle up to 2^16 incoming 64-bit transfers before requiring a rollover to the actual balance. -During this accumulation, the pending balance chunks can grow to 48 bits. +The pending balance consists of two chunks that hold all incoming transfers. +It can handle up to 2^16 transfers before requiring a rollover to the actual balance. +During this accumulation, the pending balance chunks can grow up to 48 bits. The actual balance consists of four chunks, supporting up to 128-bit values. -After any operation, except rollover, the actual balance is normalized back to 32 bits per chunk to maintain -efficient decryption. +After any operation, except rollover, the actual balance is [normalized](#normaliztion) back to 32-bit chunks to maintain efficient decryption. -The `VeiledBalance` struct from the `veiled_balance` module is used to represent both pending and actual balances: +The `VeiledBalance` struct from the `veiled_balance` module is used to represent both the pending and actual balances: ```move filename="veiled_coin.move" struct VeiledBalance has drop { @@ -86,10 +85,10 @@ struct VeiledBalance has drop { ### Encryption and Decryption -When a balance is encrypted: +Encryption involves: -- The total amount is split into 32-bit chunks. -- Each chunk is encrypted individually with the user's EK. +- Splitting the total amount into 32-bit chunks. +- Applying the user's EK to encrypt each chunk individually. Decryption involves: @@ -106,9 +105,9 @@ so that users can always decrypt their balances, even as balances grow through m ### Homomorphic Encryption -Veiled balances utilize homomorphic encryption, allowing encrypted values to be added or subtracted without decryption. -This capability is essential for updating the receiver's pending balance during transfers and for performing rollover -operations, where the pending balance is added to the actual balance. +Veiled balances utilize Homomorphic encryption, allowing arithmetic operations without their decryption. +This capability is essential for updating the receiver's pending balance during transfers and for rollovers, +where the user's pending balance is added to the actual one. ## Architecture From a10335777428a5c767b17b7fde161ba18b9e49ea Mon Sep 17 00:00:00 2001 From: dovgopoly Date: Mon, 16 Dec 2024 13:31:08 +0200 Subject: [PATCH 5/7] fix --- .../en/build/smart-contracts/veiled-coin.mdx | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx index 4abdc2c04..75b01ffb5 100644 --- a/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx +++ b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx @@ -69,10 +69,10 @@ This design ensures efficient management of balances. ### Chunks The pending balance consists of two chunks that hold all incoming transfers. -It can handle up to 2^16 transfers before requiring a rollover to the actual balance. +It can handle up to 2^16 64-bit transfers before requiring a rollover to the actual balance. During this accumulation, the pending balance chunks can grow up to 48 bits. -The actual balance consists of four chunks, supporting up to 128-bit values. +The actual balance consists of four chunks, supporting 128-bit values. After any operation, except rollover, the actual balance is [normalized](#normaliztion) back to 32-bit chunks to maintain efficient decryption. The `VeiledBalance` struct from the `veiled_balance` module is used to represent both the pending and actual balances: @@ -105,7 +105,7 @@ so that users can always decrypt their balances, even as balances grow through m ### Homomorphic Encryption -Veiled balances utilize Homomorphic encryption, allowing arithmetic operations without their decryption. +The protocol utilizes Homomorphic encryption, allowing arithmetic operations on veiled balances without their decryption. This capability is essential for updating the receiver's pending balance during transfers and for rollovers, where the user's pending balance is added to the actual one. @@ -237,12 +237,15 @@ module veiled_coin_addr::veil_example { public entry fun rollover_pending_balance(sender: &signer, token: Object) ``` -The `rollover_pending_balance` function "merges" the pending balance into the actual one, resetting the pending balance to zero. +The `rollover_pending_balance` function adds the pending balance to the actual one, resetting the pending balance to zero. This works because of the [Homomorphic encryption](#homomorphic-encryption) used in the protocol. -Before spending from the pending balance, the user must call this function in a separate transaction. + + + You cannot spend money from the pending balance directly. It must be rolled over to the actual balance first. + -Calling the `rollover_pending_balance` function in a separate transaction is crucial for preventing ["front-running" attacks](#veiled-coin-store). + Calling the `rollover_pending_balance` function in a separate transaction is crucial for preventing ["front-running" attacks](#veiled-coin-store). ```move filename="rollover_example.move" @@ -306,9 +309,7 @@ pending balance. The sender encrypts the transferred amount using the recipient' veiled balance to be updated [homomorphically](#homomorphic-encryption). To ensure transparency, the sender also encrypts the transferred amount using the auditors' encryption keys, -allowing the auditors to decrypt and verify the transferred amount. - -Finally, the sender provides their updated normalized actual veiled balance, encrypted with fresh randomness to maintain privacy. +allowing the auditors to decrypt the transferred amount on their end. Once a user has participated in at least one transfer, their balance becomes "veiled". From c8f4da869fd4799c800fb49cb45d323b6b5e3cdb Mon Sep 17 00:00:00 2001 From: dovgopoly Date: Mon, 16 Dec 2024 14:13:57 +0200 Subject: [PATCH 6/7] fixes --- apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx index 75b01ffb5..f00bfd28e 100644 --- a/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx +++ b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx @@ -308,9 +308,13 @@ The `fully_veiled_transfer` function transfers tokens from the sender's actual b pending balance. The sender encrypts the transferred amount using the recipient's encryption key, enabling the recipient's veiled balance to be updated [homomorphically](#homomorphic-encryption). -To ensure transparency, the sender also encrypts the transferred amount using the auditors' encryption keys, +To ensure transparency, the sender also encrypts the transferred amount using the auditors' EKs, allowing the auditors to decrypt the transferred amount on their end. + + If the global auditor is set, it must be included in the `auditor_eks` list as the FIRST element (see the example below). + + Once a user has participated in at least one transfer, their balance becomes "veiled". This means that neither the transferred amount nor the updated balances of the sender and recipient are visible to external observers. From 2c33517ca3dccb0a5397c4b348e30880d42e3221 Mon Sep 17 00:00:00 2001 From: dovgopoly Date: Tue, 17 Dec 2024 16:36:32 +0200 Subject: [PATCH 7/7] added docs & fixes --- .../en/build/smart-contracts/veiled-coin.mdx | 74 ++++++++++++++---- apps/nextra/public/docs/vc-diagram-dark.png | Bin 0 -> 58170 bytes apps/nextra/public/docs/vc-diagram-light.png | Bin 0 -> 57330 bytes 3 files changed, 60 insertions(+), 14 deletions(-) create mode 100644 apps/nextra/public/docs/vc-diagram-dark.png create mode 100644 apps/nextra/public/docs/vc-diagram-light.png diff --git a/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx index f00bfd28e..06b725c3a 100644 --- a/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx +++ b/apps/nextra/pages/en/build/smart-contracts/veiled-coin.mdx @@ -30,7 +30,7 @@ without revealing hidden amounts and other sensitive data. ## Veiled Coin Store -For every veiled coin a user registers, they generate a unique key pair: +For every veiled coin a user registers, they generate a unique keypair: - An encryption key (EK) stored on-chain. - A decryption key (DK) kept securely by the user. @@ -73,7 +73,7 @@ It can handle up to 2^16 64-bit transfers before requiring a rollover to the act During this accumulation, the pending balance chunks can grow up to 48 bits. The actual balance consists of four chunks, supporting 128-bit values. -After any operation, except rollover, the actual balance is [normalized](#normaliztion) back to 32-bit chunks to maintain efficient decryption. +After any operation the actual balance should be [normalized](#normaliztion) back to 32-bit chunks to maintain efficient decryption. The `VeiledBalance` struct from the `veiled_balance` module is used to represent both the pending and actual balances: @@ -100,8 +100,9 @@ Decryption involves: Normalization ensures chunks are always reduced to manageable sizes (32 bits). Without normalization, chunks can grow too large, making the decryption process (solving DL) significantly slower or even impractical. -This mechanism is automatically applied to the actual balance after every operation, -so that users can always decrypt their balances, even as balances grow through multiple transactions. +This mechanism is automatically applied to the actual balance after each operation, +ensuring that users can always decrypt their balances, even as balances grow through multiple transactions. +Only after a rollover, users are required to normalize the actual balance [manually]. ### Homomorphic Encryption @@ -111,7 +112,19 @@ where the user's pending balance is added to the actual one. ## Architecture -- Add scheme and small description +The diagram below shows the relationship between Veiled Coin modules: + + + +Users interact with the `veiled_coin` module to perform operations on their veiled balances. +The `veiled_coin` module calls the `veiled_balance` module to manage the veiled balances and the `veiled_proof` module to verify ZKPs. +Under the hood, the `veiled_balance` module uses the `twisted_elgamal` module for operations on chunks. ## Entry functions @@ -120,15 +133,21 @@ where the user's pending balance is added to the actual one. ```move filename="veiled_coin.move" public entry fun register(sender: &signer, token: Object, ek: vector) ``` +```move filename="veiled_coin.move" +#[view] +public fun has_veiled_coin_store(user: address, token: Object): bool +``` Users must register a `VeiledCoinStore` for each token they intend to transact with. -As part of this process, users are required to generate a key pair (EK and DK) on their end. +As part of this process, users are required to generate a keypair (EK and DK) on their end. When a `VeiledCoinStore` is first registered, the veiled balance is set to zero, represented as zero ciphertexts for both the `pending_balance` and `actual_balance`. +You can also check if a user has a `VeiledCoinStore` for a specific token using the `has_veiled_coin_store` function. + - Although it is recommended to generate a unique key pair for each token to enhance security, + Although it is recommended to generate a unique keypair for each token to enhance security, it's not restricted to reuse the same encryption key across multiple tokens if preferred. @@ -144,7 +163,7 @@ module veiled_coin_addr::register_example { fun register(bob: &signer, token: Object) { let bob_addr = signer::address_of(bob); - // It's a test-only function, so we don't need to worry about the security of the key pair. + // It's a test-only function, so we don't need to worry about the security of the keypair. let (_bob_dk, bob_ek) = twisted_elgamal::generate_twisted_elgamal_keypair(); let bob_ek = twisted_elgamal::pubkey_to_bytes(&bob_ek); @@ -204,6 +223,8 @@ module veiled_coin_addr::veil_example { print(&utf8(b"Bob's FA balance before the veil is 500:")); print(&primary_fungible_store::balance(bob_addr, token)); + assert!(primary_fungible_store::balance(bob_addr, token) == 500); + let bob_amount = 100; let alice_amount = 200; @@ -214,6 +235,8 @@ module veiled_coin_addr::veil_example { print(&utf8(b"Bob's FA balance after the veil is 200:")); print(&primary_fungible_store::balance(bob_addr, token)); + assert!(primary_fungible_store::balance(bob_addr, token) == 200); + print(&utf8(b"Bob's pending balance is not zero:")); print(&veiled_coin::pending_balance(bob_addr, token)); @@ -238,12 +261,17 @@ public entry fun rollover_pending_balance(sender: &signer, token: Object You cannot spend money from the pending balance directly. It must be rolled over to the actual balance first. + + The actual balance must be [normalized](#normalization) before performing a rollover. + If it is not normalized, you can use the [`normalize`](#normalize) function to do so. + + Calling the `rollover_pending_balance` function in a separate transaction is crucial for preventing ["front-running" attacks](#veiled-coin-store). @@ -274,6 +302,9 @@ module veiled_coin_addr::rollover_example { assert!(veiled_coin::verify_pending_balance(bob_addr, token, &bob_dk, 100)); assert!(veiled_coin::verify_actual_balance(bob_addr, token, &bob_dk, 0)); + /// No explicit normalization is required, as the actual balance is already normalized. + assert!(veiled_coin::is_normalized(bob_addr, token)); + veiled_coin::rollover_pending_balance(bob, token); print(&utf8(b"Bob's pending balance is zero:")); @@ -308,7 +339,7 @@ The `fully_veiled_transfer` function transfers tokens from the sender's actual b pending balance. The sender encrypts the transferred amount using the recipient's encryption key, enabling the recipient's veiled balance to be updated [homomorphically](#homomorphic-encryption). -To ensure transparency, the sender also encrypts the transferred amount using the auditors' EKs, +To ensure transparency, the sender could also encrypt the transferred amount using the auditors' EKs, allowing the auditors to decrypt the transferred amount on their end. @@ -481,6 +512,8 @@ module veiled_coin_addr::unveil_example { print(&utf8(b"Alice's FA balance before the unveil is zero:")); print(&primary_fungible_store::balance(alice_addr, token)); + assert!(primary_fungible_store::balance(alice_addr, token) == 0); + print(&utf8(b"Bob's actual balance before the unveil is 500")); assert!(veiled_coin::verify_actual_balance(bob_addr, token, &bob_dk, bob_current_amount)); @@ -502,6 +535,8 @@ module veiled_coin_addr::unveil_example { print(&utf8(b"Alice's FA balance after the unveil is 50:")); print(&primary_fungible_store::balance(alice_addr, token)); + assert!(primary_fungible_store::balance(alice_addr, token) == 50); + print(&utf8(b"Bob's actual balance after the veil is 450")); assert!(veiled_coin::verify_actual_balance(bob_addr, token, &bob_dk, bob_new_amount)); } @@ -612,7 +647,7 @@ module veiled_coin_addr::rotate_example { ``` -### Normalization +### Normalize ```move filename="veiled_coin.move" public entry fun normalize( @@ -622,6 +657,9 @@ public entry fun normalize( zkrp_new_balance: vector>, sigma_proof: vector) ``` +```move filename="veiled_coin.move" +public fun is_normalized(user: address, token: Object): bool +``` The `normalize` function ensures that the actual balance is reduced to 32-bit chunks for [efficient decryption](#normalization). This is necessary only before the `rollover_pending_balance` operation, which requires the actual balance to be normalized beforehand. @@ -632,7 +670,8 @@ All other functions, such as `unveil` or `fully_veiled_transfer`, handle normali All functions except `rollover_pending_balance` perform implicit normalization. - Attempting calling a `rollover_pending_balance` on an denormalized balance will cause an error. + Calling a `rollover_pending_balance` when the actual balance is already normalized will cause an error. + You can check if the actual balance is normalized using the `is_normalized` function. ```move filename="normalize_example.move" @@ -692,9 +731,16 @@ module veiled_coin_addr::normalize_example { // A rollover can be performed once the balance is normalized. // Note that functions like `unveil` and `fully_veiled_transfer` do not require the actual balance - // to be normalized beforehand, as zk-proofs guarantee that the actual balance is normalize after + // to be normalized beforehand, as zk-proofs guarantee that the actual balance is normalized after // their execution. veiled_coin::rollover_pending_balance(bob, token); } } -``` \ No newline at end of file +``` + +## Useful Resources + +- [Veiled Coin SDK](https://) +- [Veiled Coin Whitepaper](https://) +- [Veiled Coin Contracts](https://) +- [Veiled Coin Move Examples](https://) diff --git a/apps/nextra/public/docs/vc-diagram-dark.png b/apps/nextra/public/docs/vc-diagram-dark.png new file mode 100644 index 0000000000000000000000000000000000000000..34d18346ccf9a3a4a75c4dcfdcff5f7094887329 GIT binary patch literal 58170 zcmbSz_j>+-=Y_uT!u#xV?z8t^d#!czPFqu%oRpdL+O=!sswz<3YuB!C0)J|V zZvp?(z~RAm?b_>Ws!%z7U-PXDl9ap84{;|mXiQ@WUry0$;?(==nSJtxHuFA{`2Xjxcq?T%d{Z21qYUeN2Xc=^;b`I5 zxESzT8{yPu#bqLp@GaZuFQFKZZG{H5|CUf;bL~d}k<%okK|7E=(jaQwkog{>4?U(y zpP&}PE^#ZTB{z48&wu{EpyF>vgNYvZJNeJ2Vp}#)kaF6=ma>C1036-EKF1ZJ*)ff}_c%;f#lsAVu^o6`3k=$<9 z%}d?M52q6(|Mt$52t@6|0&`ZQ?3|+X2zra$%Ecq~%*1VvHuT%2W2UzmSv}XN_5&aM zkOR3_fma-;>^0XK4W(6glCRD$^zF*ZN;%9d9lY{{%1;HlT{&j{5G4C2$y5GGfBifc z@j{&pA84E%ALX3Z(Q}Y;uUId}h(${yK_; zVM^jGDxMBl=6SBNi)oTWAff!d0yKjHV+0#z!VN{6Pv8~IDdRpP{b%9F5x^<&(xfo% zr%tUPd$Opz7OT=cwvFIes?!N#CSha`(`iTCy}xc zvGh3OKGQ7E)ukZ4!68_ryItM%CmN+nPZ6*_rcPN~W_VXH`0s-2I;YQDwbfacGSk0? zj5Vm`Q=FrV3EV}jYpZzv21h6k10Tv}^p5~9kEhLG!^xIo}Hha@6bDl}ew0rz~;xsJcbMsfBkXotPx&jX+ znc2shz`D<$A6l3TU9i~LwBz1cNrHr@7(KFrwA@6x_{l;nX=XoO-Qs%7$|7)qVqBpN zBlo$pf_$VhcZN^9NZi24bhX&w7S=t?&qr)wEv9`^Jd;__;@DNwLT1AH1%xM*H1EkX zi3E-jq0yF3?TlgzCNjNxBVbuCFQUN5+!vR|8O2&~wix7H0npCc5ko4N+qK^*dzuPZ zbXg|;R{b}BzF!mmQ7D|{6YLm5#&@>&!N-(g+wIcT72?10*fI|v(yVkpHO;J9#zejJ z(zuv-g117CK5JPLA1!1{%0tQ)i&>jiHQaC6i&msZ%duI2+=;Bj3;_W?e-d7i0( z{OXlf!PZp6ONjQpd4~8mA&WD(>V#Evsd4sn_z#AkKdBZvrx3|^@0R&Gm}}0fuIMTD zi*-2`#3jTN5Lnk9z9VbTsK5zCZ0HY*CVVb?HYz?o@)#!-&8_*o_yTn(el13JY?`dq z;OP&)fw|b>3t+t-S0!i{cXYC3M8z;WaqTcRsc!oCH9c}a}y z7TH2OO@H6IbnjWnI9(s3!mYbwQ+fv^n_5%m?|vhT57v@k^5=1*U!34IS}sMZqGeIx zm;)(3@*W#ujZ;K>yf`GOH_!x60~~03Lf}%qFfC|G1C4#Rj+qk&<7doPw^KM<0^mtn zU&t9|d=UMRzlOaz*NE3eK<t zwo8+yOE-uLj-9RhwYIi)+%%U7bwUi6ot_7z8ov;M4Ag+W;E7JkSV>PCnVC7` zovo!Tn}Ub#2-WSJUamvHoMnnW7T7tmBN77vllLBHQUvKu9us5rzQiJw<-oZe@-%=k;gIC|LocD zT-wC51se8;lX~=vZixLm_BKWlwYa$Nn&VE9*|wg;u?86}S=%C}!afeM6N2FyXX~~L zIYvqDxWb>t0jZD|@(&}yD-5R{vzJVefe_fuhDQZ>X^0OMQ5n;b($GgHio^bstX}V z)7)+)QO)g~Xe@r8hMr&brcm8XcX&`yZA(Ic%DC>0$L(YYruE>Mz55Mz1FK@6LGg%zP5WgK%?dCqhP*|Y7h9&Mtg_M@vo zqtX)+t|i_qgZ;~PF1G{w&O|OL-}qkaeDOy6XO!e>bLUUv=|bcUdH--^db+Ey=2%d; zt^s=3?yD}j_qpP@Zy}CgbF36!1n$~Ez^lhH2`_awW+jt{F2X|;i$Lzd zO&IB&h5*eP1TLnqnQ}g&^RqbXUjE%TW)2E{xpsE7#ka3m_+iBgwaB|lO|2F z!a%~Bc)DjA4fYOPLBJ_~t$mi?Qj7peNlCRN)>zntQ6*qH(N5@L=M4E~spmc=+kEoS zPfJ*!S1AAX5|}7O4SyYu5zxuv9EN!hB7iLo3i-yMv4?s@SBF{g>u1TSAqH``Yf@gM zoIoGa8D=b>#c0Qn6LLJV?=55El7?9NBDvULDz;w?bB`6U)x_|~f4^SUyhby~nDoFj zAV+HSaZs~%d2l87tYInQaosn>%11$Q;yRVe&mNuMKa^*AgCQU;CIHEZLR2FfxDsCPybB~` zgdvQMWzN?QFx?g|Ca5P(Cn+u~#GCGu%}cmG$=VbzBLig>qi^pDG@H;=YGvpCIozYJ z_JyA{#apC7&oN(dydOX5x9@G*4Oi!!`eTP#9EPV&?;aYZIX7vzjNg=VEogZf5TKv{ zq~dMvMB7pDuhn#XJa~nw`KJqJfU!Dto9}v(eS=1#T!kzIyP7A{oGf1-56qGIox7?TJanq|FJ9Pu{(ZjKVofsE~QI>xef%49SEVy=m zJ^!l%K;dB^uRp0=GstHy8-;Z0CQaE+*J+n)irQANVGa04zhKeE!RdzsaZDmB!&8OQ zP@Csx9>QH`ruZvtp+G{Fn)|q|xhv(!6HyX-+%E@s*J3s&BW*AM`Z+Vr`F9r3LsT+{D zUmlBXALIj}sEW4era7042X!Vsi#c)dD&E`Kxo6kTGMc-=g3{9B;t!KF{x29ps!1Jq z7(4M01ZI*vo?G}+r89+VBH`rarha>+^j4E{@;JD54DE!+1C7_FB~MF?N>UqtUkA8%g4Cm^F9nLCqSArS@U#jV8b65| z`-?b}{o5f^<%SLpxMM@71~+><4Cf}9e=su@cq3;<{(oV?`h?y?e3{FoS7ReFtnb!| zi9PO5baSjjAK$q=UHs8TNX7u+1sQZrciKBSo!4jyG)vcznk$?IgxHc8$n4wr{?KYk z;w<{%G*J$rpXpgUl2^$Bs^a-6)T94g1#iDd_6#UE_fUt^K?ZnQHKzvfn()_5=d&-k zb@I_KT>-H3%+F|skO9K!KORGnt5&Lg{ZM6bDHFW%u&KrN=O>D`cG@m}Cn_725}D$C_&}GSd z3aRSPC^R~lC|d~R?mPa%j7ijCWOZ>Vz-d;@&LInE9Wm4i!JA;FTI;>DE2O-N+;E?~ z0#=f@Qc&I$h?%ehl8lDR#_%M6IeVaAt6=r`QR@XBOAPK_#p}0#0FRz3@iOn(2 zuh@OB<{Ka*Smz(@JQn{i47$WN8=Y&acrRtKCehjBw-d(@bNoTX^iE3gc)XYK{xDhl zwAQ^3oFzZ3h6QJM>@MdbHQ#8cpx45a#-^IAC0jn%aL;P%M|J}f!RRH|#tzVf$jUJb z+~dD~?a={QB)Z;p=r<2^^~Gt=23~!U7?*Lb@NX5?Ojn7lE)2+3g%U4~>2QjH)UVxtG~s3^o)UkeBksDHIi$HOA^KZ5f7l4mk9BLRlvj>r(#f`J zcRa>yn~(wjrFGm-sWcUkywXg ztC7_?JX`dVac=i&PsrGc>&E2tD)E-?RE@<>R`q=UIguO+5+v^*gLKT-s#513rafA3 z_*@gzU+1=fU!0E07n`kUkgeXB!Pgzl zv`>Jw;2-shk?!yGD^x34-1EdAdi%7lE1U29{fm0=<>u@CB)MlM!qr` zC(I|eJy^qvZBI2wIKY)%jP%A28vCOJXLr$mei+oO(a5x}{8nZMpv)$uwI_jmzT}yx zVX(p;vorDHG(e7U9gs}RY%>ro2$Eb78bIy?DRzrD+j;#G0FMi^^+Bvv%N{v zvVV|2I}ABf)HUa9H+E=9Vp8F{5DL_{Vx_n_Mw;-9CH&eiNv)|+_6c*S`8YmqdQs9R z0-f;~r0jV#W*aAa-;NF3sKCa_f#4<%$)M4!on0b(Mg=RIrc={sSSY)y<}MzlH9yH5 z!oHNKNqh{foiGlV%2tlenDt9v|7BLyw5IF_Zsgr&;JMvSVR=g?o7|Scd+guTrQK#6 zU=X-fJvLX0SS&F{IfSqZHUG(=-F$cBPRhjvP;vb4C6>)A;-QQ%Z@L5@YTUfN)7Ov5 zT>L8$3Xrs)Qn~oIOt6bLH6Hj6H>SyDogwqJ|^_w1BsI*4NB+=M2=7< zyj@z#LgA>eG=);Lk1j5lDAvFtRpunP4gDp71luAFQO~r2d&r&^&|jsti$+6>cI)lN zgZOj^XPUInT<&QdF)x#<$e`@$o>rxH^?(&yirkJ=?wsh3A0*u)Kx&oyUC)oxiBoI% zSjkDqoI#j};ONlMCr_UXyF9m%|IX+}FT*0t(kFEoNLm=UwvYu)#vtIoksr24^Fsgm z-zm>w!i)xvS>NKhObVF#z03xlEld;#zwKXMPLD8Oj@sh|Y4_8ptsJ$o2dX;C@_((P zNgC4oqLQ25RJ8#^l!KD!Ha)`z&{Xh1>pgxS1xt{6X2IC`$)il?i0#d8G9ej#*{G9c z3U>Uzc)0AZ4;VL=;=VGER(Lrztd|D`V(t@%yholXqQg0AP0?C8wPhD;{k_c%UGr;L znKylp$EG$9FOnR`P~EG@z3r`75f=ATWJ!MhpR7|uVqQs*dj#YJnm0}NdsYWX)AJ2a z1-rwlPx`RrrqyPGN=p&D{sy5@Xw2_3XqAW*;E1u0B5!EM+Jz40n~B5f4ce z6Q~(d#|qNA{IW0H4?ZEIe>uSr=|iZuW%}cz9EwYr`7|AuHL-&N9_aEbD!=D!p|zdW zJPc2MKrUmW+^3WyRIVXzhrPcGz;t6g5#l=ctj1AT{~0iy9h*Hbb|V9-KBun6e3`1K z=jVaYJ2LLrws11HqnTOGa`AKz3Pu{ZsubaKPXmp4<-9=4(YWKwitqO$Xkt- znc=ChCMM&aH9@7)t=n0NKC0!nYgvshn}LaSpK(4R%M4&*0NnNb>kEO=?s%K$oUIt( z34xwI)*rOlwJcz(e|vhTelqC}KnB zFlMv!axD>g$xhrNb(G+DqAR~5kOKX;HZ)JtD*Cq002J^2*26hrJD2w3js&oQ;VK~M zcc%)TKbKtpl;IKZhcBq8)a#FkQ8onIhH$U#EGZg!ANKy{>I_dbSb&7b#)e_tclVS2 z(n&&5nTGfr%lw#$!zTKC8>xTp5d7;;33P`XRCUr8uEkC21;^U_w{_))R5NsceN0U- zbyv#QQHiu)=XAjBVFJ0E0-{3U;f2Exd9s&7!qhL54J_5*qgi!zdN{V>Ql2E__Y(3a zdMp;|*aEf{DQR!toJx+ro9k?(fes=~d^^7G{8yZn#JN^lW)q&j+%M z%(akNe?Q!A!ZRBi?VQoeVJSzMzMhV!(p9-77q6t#23#bq^$XGG>%VxEjcq!LB5oYu zxZ$#0WX)-3lnp?- zqy937@TzI~e(x3ar|==LdULMfo^%YDVofaBBIsmA=ZT+JL#2&YwQ@n)oyahNrP^a` zZssXL6~61)Io!K*b4f3Fh%=lR$3xFg930f|cPaUI4dye94FE{@g(>Tu*reU=SY_9D z)$7EEV1VBKA88Am7T)c#8-lq_vPOuMFFVoCJFpy{j_IT~2~0JuKH z$s5%=PV$`p?7fcII(L$xdk^B`^H*F3BmQztsDa#_EM6#$7qAShH?3{dO6s`?0hj9m zRXyjz@gmO!x$2%XP=|?)v;ekhOl6^@`&Y^zE?dfk>JJ0c%CR!uQeC)W{ZQ4y?mz`J zFvP4E{2V7c?Aio~;77uv2i5IyQrv;AV~*z#{4{C5kX8ivpMDcZ!lRw|lP00ku%sB@ ztL#*4@96o9uJJSNhwsp3B`PpUH#K^dO0Qu0>R7p$I%0XE3*FMFkH)L_d}buQzEB|i z?itN3wlwEwXD^6U7VZuM3sUAsvidA^o}PdBX>7oMCo5A{#`H;m``AYr@csY*FnC^m z%{Jr-e*+>Kn@Xe6%n8H=@D~$@{5H))bQIgo@-QY8&!f0!j|Bx2KQ$Dr`v;_p!p8z7 zl6oCUewnRRGQzG?Nh(0aM$WHz^Sl7kFVCi?rljP%>&qSN{orpij(lBk(xa|*+h{aY zzS&`9jYkh42LO~WH-q<<#?sF{antP&*cT(GGf-TP40AFoaT<+u?bO?E%a5D62LYcq zxXvxREhvbm-<=Dd%wCvX#opC~ytI*6P_`f|pWIQ99M!cl*lCsp3!ftc^4?a|;yWX}NQ=8AzMgZ>+S zTX+e|ZheUdc(W>Q606>tjCM;nAGlL;e5#3a#=%_Mfc}z@S8((FVol>D=T~eA4yUzq z=KQ%zE_yy~y@f6BM14tiNW7J2*q-;(1Xkg8!$dqfd@8+HjWi_JtEm$2%HEPERf2l& zFYufczriIhC|O$|ny&8Ax=dFJ4NccfllPVzPXsWis{)Coo8i!7`}r#Xu}c9?3z&d^ zL^FxtnhtAu-yIr2Z8A_e{n=ZF@T_OM1I)JlsB1!9td09a49~NE`d^08lFRF{#{#6> zp{fZ7z7aXY3sTkYmJCXwWFAN4AvR$ddbA0-610Le?T*!o-DI1a z87Vm|qwBTUJZyTx7;d)W8qA<3CMF-WN)m>>duP7*DVX|KvBXV0a5OtPkS-qZIJh8L zr+Hxh`fsBlN9^@$ki#XGQ=9Ft3uW}+&68($u5N7J6HD?Gq=bwZT%_wsT>6$Fya4|I zP%Z#)sjVze+T5%SU9QL!o-u+m(7QK1c%3(`gd05M`9r)X@3`IJ;eOioNw(QV{=0lY z0Dd)uy{Jp|ZF+W#_AgYB(wP;NAM?uq#bu$fsY^i0gWB-Y7v;E8+5QBuz94akhUY)^ z_RABHFo&G!N_9Za#%kvyYyEb@ge$U${)0#0Y=akDCnUoILzVD>q&v?keLGjW1VzMi zkbvT~8@a-Aj^Ee4BoU0T3vG2<8DKxan`^L)PR&!arHB{_6JOwM@(|3&N9lcVo)V$n z04U}CLmU^>hL0y})F zj0_D`f!#5jw_iYGtH;b=Mb|4rZKIIp=|)I8(X`AkB>%HDanncGPj_`PZQ|wwo@<&I zT99h|6QtvOJD5R`PD55qtvA=;>u)yL}k}(v>cj8*>h{jZrUS|@8$l=PZ!xeyTb6?jc(dz z6_jD1gl0c@#;3Q{EbR0^?N0yRyUF$ji~mlZv`gss7DyQADX(NJ{0}#TqIwMTOmVy! zC<%ctR%~4<)7l;D2h{^Ivc`FleZr>`-`^nBN4syr%_=3*0m6P^IBqVvTEnQf%>xje zRKA9Nm_GHodh~7e5|s3PVs(Dx6L~y02WY;nugPQk1(lp2F1;nPrgLoSM|^<}w1pm9 z=&z4}UCC^YK{(GPFSEFuCPR2|hHHBG1gb$u{xlrm617-hWwH6s8+8A1X*R##Fh3vx z?RVZ+`*@ax69}WxlsF7%#G)*Gd#GUT@N&$a?dr_>AmP|lBf_{d;4@P+7~|T1?@#)4 zJqqO&=HbjaYmi>7kMIz~!Wyiy=U$KmYA~Hkdf63;5BpWisbCh;S?+^M_h?3p8(-kB zDzc3w2M9$1qFFj72Xrhzu&EWB9a()G>E^KUsQ^$E@Xsv_;f0$653@M#=R0eubOP;k z<7?7J(g6onnpW;Evo)>+wKRT(=bJNt*U!|$&gS37cqh9)19yMND%wvz*nDcY<|&#p zZ_yC0MFUV>G_ zt_fePEajl}y&buKZ}A4z>P#ldl0a8gV~r4p&1+5&Q6vCc2un+}_*z6#`yeC;Z)3`v z-D_g!F&=lG&n(Ki(r#XDn-I8_hlZO@7T9S9Kv#jpLGZ;i#2kK<32M}W%XR0yj2=bK z<1B%sDzm{haMB82oI^%ATH2XNlj|qTY&ol zGd~N`b)m2mP8IN)mHa;cxQD2XFO1qUa% ziiq&L{{S+XX$IK?l4)rJy6CHU>!+d~Y@k!ESs%x{LMmiXcDl#hXFwtenAC11`Ac)O z$6jwU&!kI0cs2$CCY$DZ6~*PbFoZJh26mo}ouX8#?90^KtLvpAv8qe5^sq#W!OR0cx(YW*3bczA3k>2vb*+H<=K*!I6;*=GN}^O2S>0?pxGSNk)DCbk~RH<}M_o zgGtUiu^NDD1^Hnd+sLWaT9A1=DQu9HZ?9uowv-Jh!t@Juz`Ux?y??)1NdDGiP!-Fz zH;v}8rU;-Wp!seFSFT<7({6qj2^&tpjkszwO5uSz!zh|M#Diz#GupG z%YuHPzcz#=y{~m~5Yi#F=G@9F_yB96n(h%C!xjf#3H&cLX#a+PW3RayptACv$Id&p zB;i(XSk@0EKAM4#?{}(F;Jy)f?#O?d7K{?7au|# zVku2!uO-n6GI1^~9mo2sB^ru%ZGArXzbd{Fr_n7%Ba5&t~tE^{$KcRbX4)L%jG13=~ zB?o}R^6zl}eiGVhHP19%0G8w*0T&EBRStlv>$6$t{JO!K;QDXTp^#g!zU==kgzV8e ztRt)*>+kedN7BW&Nmc~_L+cuXHZo{qTVy19IOqleFjG^yS(eJo6}~YQ1YJHmR&Nl6 z_0b3j2(WBkkn|3PYF{P;tb2pTmq%SQ85IK}H5TAywLkj3(gw?sqxc;x&5f%Bm;su@ z=+Z~@+rVs&bN|G1b7<@sf+322v*KAq`}^y#KHL6!wi9*Hf%T)LZo~ET<-{G$DU$&3 zhYtTxr1}URHFog~PZx@GoX}{^gIpqMuhXw@AdY+1ELTgMH>W|y4XK_hNxPLbu;d3%odCszgO~~XMkg@_xPF< zK+lfON$GPPE_Fk@gZ=0KpSn)@Z8@D4?O&xEbwCX3Q*RbZ!LgJ`tU{s&4PnuvI|->v zDm=5{EkG9qE)RiK*-_j>tEqBv_CVz$ELI0=;t=S~+&rJ7t9u2wKIBO|QKH?E2VR?F zh!I&QOuKPf3d9)Av}I{6Bv+xw7r)hMm@D+U=OOQioG!tw65;Wn=1$2YmRU@2RWS{U&D{nl3Z{t9 zZOKAWfc+|x%qyO2OmSHXJI;_O-2d%+{qNzo3u^;DaIEqb^nu3zfkKt=C?}ZCJ$?Lp zY8l(EuKq1d%Fl79TOz7(9OXdSdC#K`NgsGyF9G1O;ge&n3`)Xnk`<+VEF2vEWL^A) zE;Q@IS{3F^JkLK@2hvh~Y^k6s+F69LRYObngYUBAj#`77F!bAXWrVvgpW2;6`5w+O z9tTVd2qYcZ6HJ5iD#r;BK7f@R{Yl3+;5dP8s(8-?>c^#h&-~?di=~H@2Qw6q zsaIk%<;r@}4ar`V#eG%kO{B?iQ2sYYkDR$=G~|z$mONB*2yawv`;*~cC6TXMvbBzR z-=qCl1%ZMh&fggd(`2KV)`s&#WZ*aZ1jYhu1}Y|07cV)3Z! zOn1lbaAWkc@catFCel@pZ@TGC2F}_(8oUz8vP{e{StUkr-68LPO->k(avf?WLGfo|9-6x*+$^Eb%!5-saI& z<%a=1RKO#IwR>sGSjKN1t&82D3LA~=Q8+z@?JPM!?0F;&;S9w|f1Y87EtcygR$pP< z<7RB^=_3;Qzj}xFKA?~qQO4! ztP4N_acv_xFT(LLfZW~ME_AY;6tE_@dy<)Vh9!?)|Le;=0iH?bQdQEPX>UTnE0k0x z%57jf^6GT})MNqfrS+SC;G^$EEZskF(^1ItC*$~dK<=fGh?W-~qvszQ25GJ~^Zw~j zR9K}5a}tNI%dpcai$&>~6`~2e5(Ej>?MI|{ltxBK${`y=`Hc-_E zAS2>+b4f8)%|p^Dl_Nnw)#!3*>t)=xN3SM$Rj?4UU4oyXPnUkv@e;|8iK-6kSw{_oG12bLcP@=78GrLYT+(m zzsY0L&zbh7!Y~&=F#D%<&^$Bzb84zdfrS*yRfl=5-4S_2{~H`fo_L7~dOH{Ncm9nw z!ne*Udh+(Ti13RwU^$Dj^MSqv^;>+Pq4Y;MTfhzX1?Z4hI8}9X^1Z<8lyN7Lb-Jz; z3$An-(cl*-J}H2U<^pyi(a#I?JbxBmA#mk| z!dcA3=%d^7<>#j~BOa6q(ubR2x9Ow7acgekViy<2_~cM^?&^FL?iQ7w0h>bKBLe>j zXEl|qR{%n3K%Vg}gr$`u_{eQZM+r}eu)}POu%NVEKQEI%HNX+-O=YE8s(e9aLXF@6 z8LHxU<^CF*k|{x9{*LeSf&PkLUS3*(3!U{e$4ZR$7l2n%T8cWfV!Xf{iuL}5<4A4AzT*#i7 z)4Y9#R{JS*B9|#+@DSuY9PrErn?Hi}`Asn(d)98wGh>xiIBL*n7fui!8mw$Dmx@Na zbCsMJg&ynoRdkD#9y7JFu{)14de9XM;KVjRYLOkGj^Uuc0$G(CKPOz&YNv!3hZUDS zvkHzDeWl6Ao*2S~6s9CQ>blWhN30b>7O9e-oX#jRqr0YQh78X9l0{bh`JxQFuRFr} z{($}(w?UR_J0#JCz>ulh8i%m}#-(otdlSldgUGOA3n8F9+?=GPhKS58&tQSd|F;=> z!XNFzlg9|P5zTzU1oJ)&c8T351)1X$|NagZ*O724!IaTd%UC87R8N`rUCtTfKO@t_ zoK%*$K}UF|li;Vcu!tuPn=ao!E?%ZQ*~9x$RZsZ-T+Ir)N5gXQZXQB8^{dUR&%Hay zXAXLa-037&d@>-CNQ&%X=}Ngn+r8h`C^nV3BLf&4<6=oTK2Yu=S7WBAbRPzO|CPQs zW}@0D0(n}`6#2@hD(`w6;n?uw=`0xK=6oF9N;V}1xb*iz zO*{9T@;r~V+ma49zZH76_nC?;PUenNg&+qZaHljBj##MAq|#O3uUkJhe1}f_rTJ4? zY_LL=_$^4MfbB@a7YB5a*c;1(-O;c@@l6Fu(O~-_Lk2JJj-lU5*%& zkGORmNi>>e)c5GypP39aV1-dWQivduut;=2z$Z=(FRnjnet;oaAW^ZKLUsC|^}S-u zcYz*ecvHmRUrmw+7 z`WnszzUv_cMhhL;I=N6oTu@Y^^&dr>>tWspXomY~Cr&yShl<1>_Cz)>0RsDLCGOo$ ztIITl$YxzCfK37WWlJf7c%AQ844ic{$?%9UMw207{{F#iXJE0CtslqvTQ>d|Ye_V5 zuPR+t@X2XmWUKR2cAp1lpLscTrQGlg5Pq_2y}3gS`!x++)}iw2l|14&!?v?lXz%e- z`LVW1L%uSd_|40>I&<(v&%fPUoqi1K<48e;KaDz5wFh^diTZyhU=O4MEuv>j8M-;e zrCZnnU5;7inQqom*tZ_lmhTYJQSJG793XOQZ}flg4ZbGsSUI14e=h`%Y*a+5jnnVE zsh|%VJnpmHcfISM@M9bP0>{cfjHz65f>zfQef#U*%gT27XU(3^ zPio)ndv%Ht@1BQvE*!r6@ewhEXN$lRTfKJuTiM;y7{u%WPi7O+E&P26c}z$rUtR42 zawoFwTDpJ;UBCg}T_?RqXz+}o?ZcV%;N))9PzOgJufwL|o@~xRJm5@N(%Lwy4>S5Z zPIdi{g~H*o&ysim73IST*{bO^Co0t)f@8vxRi)KzjLs9{9fHMMtE|rK38lm$hlaPK z1_?^S|JD~Pb9Axpu#g#2ZHF@HtG@y!eT6V0CK!N=0hq4EUP9>{b`*W!>-%ZJ<<)lw zq#90qU_!iOwlb)+Z9ziwuFx3S?-epPysr@CpoD7Dk1{fBhfr%E-tgMati`a&LiIPv zP@a3ota~ z^xKCiSpG&@PoDQlSij%dW0ErerdR&TRq4f@1FCltLaY}I)7`5jD4zw<5uT?HSQG8k??_cQV9Y7owlr#ZY|Z*xqem7`u#kv=1s%^ChQ`u>Q!x^m-R< z;TWyEwZw5|1(8;_BhD=+jv?Hek31rb?`#{07-+u)nDV(O%dnQ{BfLr=1>|rCgXmdQ zq^zPG0z~KujK#I6&cmKW50N$-0L*1SO}EICQiig&YeZdcy*QmmsE^n%RG+r&b&$YQ z%n!4}i5X6lQS@1U{Vq;Sw|A(rz?p%+881Qx*@9u=OC5X6S@&;qsH&aEOwe4sn|#6s z*{eW42|IF*_PZ7pg{W)_*gI&;Qua9>SQoSKCE`$DI=4geuqR8e3U(#k#jJ_1+FnnM zbWI9PBMIiTs989&|4cFxwsXHq4FEK*OL=6p-msqN_st9UZJsU$KR$RzwkdXQ!27P# z%6rPvkn1f!RZlN-KuturnV#o&R4Xa82k%8)af1E zUerxxY_Bn|ZrQpg6)f_GvLT0DocSDOF2F{zBMm>E9dBU{j$Iz7ba3S07aI9a7l`3^X!m*+lvn*%mB-3(2 zbC;w~65GLEsJ9m7O_4Kx%0w^eev5a9-I`R?;3nS#%1w0l)|=pSB09)8_dozdv6iL zq5Eh$;tlELqNro&z>grMJ5IkSPB(iiT<((H61dA}E4XLAd%^zd#c@UWWRRF+2*&Rl zr$2u!%RQ~A4ITVH%vV1lh{ z&iuICUQo~Awd<_nKmBoyjFg$f8AUsHW-Ki)r5?9Oc|Ez`<|tA2Bl+y`u;jAz+x7Fp z438AEtho8Rus*~^FD2>1fz4#?4d@%7U^~i#2)mM6z}1 z>m9O_mV{`6bC_(Ao^WgTDUAC}>@Gzt`A(~G0L57B@#G9X!-L|ukd(rzV0NHx$#zu- zj$L{Hph&VXVJj>F{aIPZjzEyzxn0CO*V)HKaZ)X|@7BIrh@Ym*gbq2qTs!&Rx+=cD-X!6oF#E=Z!g&CCO*x-GIYE^He%AbkYyj z$1f{=LDqZ^G_ynG*Q66|E6#Q&bdhCJQS(CSp>)8y+T0Spm(=ZY?XHNXNMPWOo4M;Z z9u^Y~mHWFi#2C_$-@xhFk4@2>>4}8Bx{DlSF%<%Z6gqi9KHhV?oUFrU-qy<5eN0g~ z%g6>eORFnq>(*0bgD<-G^sk9iFLlLij?#dUqwB+k7`7zAmhw0O)4E-nH8y-J`7=Q8 zXQ*&_^5+}5$AKr+4gq)#Ioz$M#6P2mV+|``KrHqWF5=D?dw=;RzTKq>q?e;~d<&nK zOh%j{4TGLA?PpDL9G^Yf&*-&@6-@4QIVQSJg6TAB-$}>CEV&@vr@lbS*dA(OdLJof zjXauJP_|$E9v-(dj9=+|e=XlE;y-iFt~$`rsAaRX)5`9<|KKdKrwStTcbnQ}br`=DB~i<*i5G|7ZY$ z2b~PAV~YvP(p~N|AXBkya>R>^iGQSHi%(dH*1m`9jW_X!I(F&- zNUeVfctxAP;lO^>yLCw??|%DY6+3aU7qf7n7DUm+j#)S>VG-^N3hnMp;ZTy&w)lJ> zKf#9`48mW-wcMQKv}n~ z`-B|SX$N{95VSIrydpNV_;`l+K>sV0K%b_!9OWzz@-G+Ej$n zCL>B2H#$$ho_YyO>~;Q##i2;F3B(@;60#JYH?}jxHd-qLN5ypB>A7&`rGIw! z2w_FCka1HF(X>FTT70Vt5M<%j8MnOyGyVHc0}WmHXlZS!6E4?)fO3IJN4nT>ay}Z2 zKFKjbojz%u`drlUWP`o~O&~P33JuOp1aIhlzQ&~cRjHg47LCF^2He|(UuN^^6=$yr z1jcXQ*-WU2A7DEQ-hIrzt)L>g=OtUiy7qYFV9<$}gXCE5{wgTMeqR2wAx~(AN(txo z-RmSL8;vy2R1M*qzlg{L$b%?17RllkntWeCw?`n?R*~S9n^ba&GsipgIlfjBKooM( zQ9X3#>bd^ABo8(S+0p|*RmM>BH$s8zfjN-C{JH#N48y_1KvariH~gYk6DLZmrl3;; z&<4dtG8`Y+b!^__rxMbutb^q@WQSurPwzptZmzorzn<3#gIYzf z2AP+X(?=^QFO$J0!G=0Cm@y=`iH-soNJdP5yYWzf?jiizz6JW3dZi%d z1rktIuAn>3JHWuFau%aaLUodg!tq{7vn}FAa3Q$8{iH;Tz#ZH5X+R%k3;t>F^*jc7 z#_K)9(1}o4f7JEl`f<I{+poor6HUe17K|=o!^G`KVhtThd7WWgLA1dQka2^$^+Pr6bv&j2^^ooQ(c@kP_7J zo>}Kb%b;<!JkAva zHFhGP%chsj;>t|+O%=h9x5t6cW98sj3dN3hJ;79M?faqnq*Nz9A;6shewhOBt#aPA zMBAU2$BYOymQ{UO8EEO)`@-O(%!Ovr>efQ7iW05 zJv8N)JxN?>rsDn{J~SMN+?9HQ;_7VlLT4k#fkKaRZJ`5p0Fa&;!|LC1Gxzz1-=V?$@# znc!mv6^pLr9O3mAAqpUf(p##=f`nxoz9@LpU(RCQqzMXDVIrbMg5Inzr1*(<-QBdC z$dZ%p$Yy~Bu^y7Rio9kDc<+0qlQv|HLLJW($EKD_QH43j_hR_~gVUlD39o2nFS6-H zv2}FVZM8>wNY`s{Y_zopG3@Ce1J~8ddP?jkSAFjSN2YaoohlZC*l79cDcx5S)q|;c zFc@|Jwo=@2uuHqT<1(3C_&7%y73%`wO#Xzy|55eUVNq^f-0%P@2uP=t146AtXMnnmRZWy`-7~(h;v{W2hSHPTSq>51ixu zCXF*XmC^X8aDIfxn)yAk;!SBxMA2+Ax@SjuLEbF5X9KU!qs&mb#h0U7Pd!#P+uAYL(Bmg2@(|1JF~0 z)|OKAg860@&#_XOUCxaQMv7;lM$Tj}LQ{_1{h3!!)m2w;vo2W*?!@K4RTcPW860p` zmA&6%u^aD~2|7fQH0PFt$8+|*R~bYBA?g~^$l-zC#uh70e$^66zLD zDyPjI<1c|BGbfO1BD~K@ue?B)`-ZEw^pq{o9N!6ldzI zkvdY}o0Jd;8Kc-!(?n_$@`V8vWxNMpDux!vPj*WUb3_iX#$5CLO=_U4hQdgB3yZ+; zWvB|B;1*+|n}6w$IjKI$r} z>pvUrVrHcm8}F4YIa|(3btm7?f5gJD8zp8!tNc$efRzgyfOmaK^%OsJHlsDGdZkB- z12oQ&zWXn&*ZP?5f(p+&=8hi9;Uq`!-+Vb@mC=Sen0B$o=zG2q-Q^&xUN;YMbxm(u<|_f%y-cpL)=)CiZ7}*9>2-n~~SS zJs=Yx=}t4D#RM+cmp!hp5KS-qe8vgNF@bI_x^bBz0hX0u7W`U++cgi-6lvGTvU|ZwmXwOyRd-LehvtTu z37Egd;@Cr)Ti!8#+_!9)+=v3iW}B&jt%w|UED@F?P$6FQQu6(gBfAwfP(X@LIJ>L5 z5gE9Y?YB`cyt*DrNxIYjNk=+QLH&J?!--`Mb?U9mtf2u6dM}U+dV{!KZstRtAzyx~ z1qVWucWdNl5CA<|b(`W7zwvN?KgI2Ubmdf0Exp(;0xd=-TKj01?t7vy`aN&{@d8AK zmjUiq69Q;ia05VsBeg`3L~DEjpFK4-Ll8}~t#6rxgl>T54^^wRC6po)V{6+*^Izh} zlACCG^E)4v((4%~P(4!Rj4R`_TQ}-XLqAv4Ginz(Q4*v_odUD3ZV-TTIB0#0;*WNV zOp{p#|L#ssOlO1W zVl815C^taY;t9o<3y5vywZV_6i+hY!0B`&p6u~5zDS=~L5$!g)#a-@W>8(QOK=3ER zAY~~hD6m7Ll=QB1%_Oji0dn^N3$~-49^D6;aC|{Lt z(jL8S&E7BpF+#6u>W_jYPs=B-(_smnGdz{U#fJZc`Ieg3&m*_Gc_hBkPIvv8SlVQg z5cbi+BI<5ker@3wpcR@xOxW0-)KVN>qV4IvJLp&B2Uf(iG|q$+NweAq1O1~>k|r_` zfipesV4seA z#Q;o}3T^20kuSAr_Yt4%CRD||`~4$Nh_1iO4EQG_s>t-%8?=G? zyOc-O4E0T?`(Gec4Fvjv)cYXVjwxX~SJ&6qG1p@@1I!GJiyyWgwmFZ{i@P0giGv~q zK0@K56<=s4u$=Sv4DD(e6O+$;jb}3-yx`I^5=+NFybAGgDG?I<#$X*KjXRafK@qufc0Q`aT_;E9h*xKKtF|<>U>eUmb#ALd~67~Y> zEu3_LW26M2OZ15gzV<;ouP#e-H~b{Drtw4d3vut3R{JgE)Oss`2a@n}2w--rfw>wa zf1mg53&Od4sjdznI47i;Zbf`C*qM3#dy9yrv&#E?jvNY}BaG5LERt3zK&JJnk)F%V%WdR z(X0(r)m#R>R+@*ex%jE5b_4Wq{?tuq$0Z;~G^wMmNiSvR8+rCA#Xum+z~8N)i~ z89rY+tOinmoBrr}DCLt(x7It{x<5zHT7;$xWYSqT= zUg3z{%{mP%?X5r5KQ=QGpwxstM!=eP-v1*IT2oy^lG8d#r8=K;sQsqX7j$&093I%k z=nMimyNu{%kk3{OL?=ss@P3c^V!qB%W+G>fr6czg^Z$Edk4m3%a+Tou&e=R|Si;YB z@SuYKGU3?)?`NSH@pA3w(8?oaY z)e4cF$D+sL*Q|S$3Gyb_aFa{bnv2#46SPrFz>tZwOt1{i)@IQJoz^d9<3Awe*zi|Q zjQwSyBNWugjL;7LNhh}yjmjQ*3lZRhRx_7Uy=e60RK-2 z4%9ZqIq?L5aubHc$7i^;&F(ag4-Nn%NZaKd(iC0Bx(p*wnh{Dr4 z?S)kH5Wl*?Y$0D92Vd*@59q#=q^)lc;*+4m0-M?jc513%#usw&oZ;j5!_!^|=6SN2 zS1-fJ_j(DX1nA%d%e!w3)hRRooo3g~3dIHOeA~$ZA4gXFGS|UH^)3$95E850V& z=@7@ysgc6CT$>I0iyem!b4-k>a91`4o`+Jhf!pZjwmVYI1+|t3IF%FBx_LqsMjDrU z2>A3X_nWW#p;}i6I8ASP$`0J!_xM?PLa|_aD?7sv^}Q|lAK6giTznCePIgBlg~f6oA~lH z_%2+J+$Z33L7dEpnkgl!m(H34I5^BBK{Y;Tyw`26FA2gSfgQDWbctOG+?eP9GK@8rwUusnY0)ooJA#&pY`oxTEBPQpJa%>~Q~XsXx8GpuW<3KrEct6wND%2Z%SyeHc)xN?GK*Hh6X(?4 zMLk6eG=k#oyLQ^3NTQCu?3`oKZBMA+Jcuux=C&RmX#KpYl%8g?Y%#@ zqFM{DkxTa2H!w%sq>1|)R*+1Dy$p*EaEdz}?vFVQqGEc#S`$iX5ZJhMiS(L;N&FPa z*BDX5!>HRI8}oivDR?StBwmm7c(TcpF9MoL4)heBQ%H~G-HuUUI_3(TmeEzE+My_N zjy3%bhVC-P+ntZus>uo(>rZ#2(M3O_6?>HK|LYQ0J$#B<;dCz#w}4m(tWZ0BXt%w?;d85`GhW4-4oXb~fz9$~OM?R%D6klLpn&_idg z{pYt?H_UmzF+OM1$&`UuJfbSdTEz7H>&b5JmU zt{&kjYCw!bxzoB%%c~FW=JR$`hp~SAUGg-@2zU3JPU$th6I@)?s&#MhRe?kK9jE}V zr@dv8E-_VY9(Ps^w_Dc-8o7KAufH@t(4E#VGDfp+8xvWMeXnpWzjf;)%3GA~=YveQ zjN`pv8tnJP4}-?C6BH_xZ-gx_G5@}u_>7~fsexKA5VXgVkm$a~Ab^(z+9aZCHFTa7 zmVF$YKm^$+^Z{e|(F6fy!#Fz#f~Z!g%iLm9<~rVjSH4m~6`7Gk4e}q^0SE%t>VbBB zl9h0x${75Snry{Zq^dJIF`)&Z-5BdbPw(9BGG?1T?`A>l2OXWy4eo_E-1^8Kc@aM1qiGFQ$6e`>&*+oa*cFEyj|<2TjS-f; zG--hsrih~Sjy4xUY6?rL6)fb5m5+&X0waM*rVz|(yfm&$_IV4oWf~+8Ew~CB zv8@5Rz`T|xxhF`S|E#8U@*bH{yt)4$H7*hNn1nzj0Mlm91KhP2Bf6N;D?~@Xng#zX zUrqq`HCzGpbgo2VmIQU8?gVt4x@z~zRAuoN8#Mp5p9r|a0 zLW3~$)tn6E#0f+wx zziQYf$5ar_g%?3Wx22Y@x&%(k2}Bs#=|ty@Nad)_O94krN(b}j&!@emyS++x0jl{J zGLi$tW)iCv3ccS|96%<(fUpK8VSx4(X14*$yDP0RqT92w<@k$*CCI~H#u#|a3sBcc zh{R_zCEjS!=p)XlI@L|uKd`(*ohubt?HMk**m91Z^a;MN_t&E+@zbYIAD@HH2iYXk%ggiZFW?dCM1^@Uj$Q5`;hm;)k%B!d zM?1J8$rc5q)tdZ1q({}a&x$8&h6}ak%^8t?i`4m3x@g`NisH=0jS^Vr^my?v-~0Lb zCRq08=?AXR)*_Y#gPLndi)Cis?^Lc6+GL^@D0}oVyc9!*R9LRQ;H(^Qi;+T&-z{;3 zbFUe88VI4fO!V!O&tCg^WP1uM@nRUnm zRVq=r+vR3 z)AT_orG~vJN@Y*NHsDz8* zn6-C$zE_$bZk$~TpR3UF3SDfHZ+D-}(t{O~Lu zVC{G)D60TJxJZ5vV(y9~5xC~VjuIb8$frr3FDOWZ*6Oua{BRP-Q z`Zjd%pr*(oHsD7i`jm43N1pf%ckYT9MMoq|@Wq{4!4GI5jq1JhD(aJrT?O8OQ*FB& z8|87EF!ez7la|8?wK#nL(ZpgxQ8BkH=SHV9OL+HIgGDc8hpki+y5b%CZ08TQ@R_87 zVbUv8ipuqI8*ZD<(sh&f5J%UuBk9W?Og`|Cg?0uK<&+OAi&116rE@_dQt3ckH5;?^~>=G9q1=7^abLAFEBtL~Hkan=>9Gu^<1wmq#u2)qqheY?MZ1 z!OTUxC9j4eF;@vaLVnYG*b_|N@u|GP0=DoQEYuCqX!3UdDS;$D!O~SmXU{rHU;&Ui zUd1o6Sp)Jf8);x0FKRLLs`{EM>0oV(?*d_2zPXN|SQPfk0#41(`G@=!Ei8L^-&gWh zbi$p7yT^oKuLSe`f|=&YD3c+BKmP0uD6OG@UW!N$D5^VGc!mi}vxC^1MDKex21EcN zDI+ctH~WNnsdX8Jrm2qyEcu_;<0b7H!RjvjQk|WXSK92 z(U}dWSki-5zvjtU@Gi_bCN6HWiss?er*&n@*T$u_#-B4r96}Ayz@maJl~ zdfV21F-CO5v(XE_T7E3WOx(0G7C9s8S_x~MXfYqUok8rK)TlT(kpn2Xi?WZ_E~;{v zXPXS;G!ysBXl!L}+mNH)Z|NE*nKpHq$Tq`-(u9zl*aSbwAEYZ!onZCLaqERCT8&HtTBbh}BmfiTmzf0o>t01GhP(E9i| zx;Ly&OL9?E?$~bK_SLPO3ThgN-Y=TOFCa#8QK(6q4se&*v1~QTCK=tdIfXimPpks5NtfM86#ToyerC&mZDg9JV5u`e5uq zS-hWVl8PmTi{(-X5>J?eM>)s4Me#9VSA5LsuDH3E8Gw1NP)5T}VAFj5vF(@T zTBry-9l5dr0J0y4@*Lob7VI{iD4J;h~XT-GnqD@-!8hG*2{-F&oH=NR1{_}A{O z29(tRL8GI&(l==7I3htP5u%ia1ghs+z|Bh?lo4NtR@^yhVW+4+gtp!YC|`S>)P*1m z2Ow}bHAxCQj974i9Zk&P~N-GkFHt!z8Lerw3_e9WUD`n7ChKW9!!m zFArRnR6AKyoZUuQrxMQ_G9vwH=t1QPf8Y*2Cq0 zc$tI}e;&P;8TPHA2&RV!TK#s06saz3@qUW%%6om7zHv4}W+TVk<^vImxjpz4QYTXs zS-1s1@d1nA?kQQaa`7rGQMj=v%^Ezvq4hMtH?izEGwG-C%BP8dfuYAkyNVM(IH5pp z2%5K?wC;w)zmOq_mq3U!$7V;;&$oc*9)#6vJvH5YMg~o}?ytlIGfjq(s-7%2<(mns z@;1GfXVUoO04fSYS@fckTucIuFkRy`VeO70RiwXa#@gMTSIGnexlMwz7W)YdOa={4 zO8VJBjttatV0H^hUza8;e<3PX*-#VNbulGusFQCkggi+>B2Tc-d$u zr^-tmn2Pz2{RH3#34#ZP|1{P_uY4`Nw6+J4`ZR)_xL%H~PXjuDhu2Y5)^I?sr4jpA z)Z)W0wPmEwI+V!@JV;b7-8B5aizBr~Zfvxct;2ltlgtd<0}lqUMC|<@S`Q^$qQ|~c zJ&B1rDXF=20Tttu?jtntqS_euaeel@&r$?pM!3|3EkZ`~X;NE@*I~zXct8GZqY9pK zD=NS2Ina!3!WD)cBbpY54y(V!C|{Ea>8TKTpt*9V+Vn(G4b?C}XrTfhvVn6qj#p;G)6#6v%&pp&yG&I{R zYXtepEa`k8k5(|R+02D;=GuAjh>mSgsl@l4Dfj{Tlf5|^NRdlpz2@by+x^Y`YlpMm zWf!;N8aViPcYSBbl=Io`8}U6Eh4s%SYPi-iow-hOkOzZwd7}Q!Eqzs{aht0(_MmdwsW=4@>x*DRrWLJa6i2W)U zT9GRm=L)96q+kmh6x)CP>AKLl-8B)kx)BuHS0H%{gAQGm%4EcI#YR@nJ-*Ywwr$_B zmjFM|g^Z{+Mng_MN=dX#mW>M!h3v@O93gs6Bo%V5KhKs-#T zM>3ykgl(Rbn+256XcYaHcyck;tp*2RG8yY-cbJ zhsMLP=|{W@xbzqu(h8qR$zY*iCq}0pk2&HTpQZZqW%m>50Sw#snhxS%iio3K3Ls@a zP^0=y5&JwZ@p^ofU&h;#qJ21qZicJ-BymgpabR6q*7Q;o(WB#}G22?O`J)=O`5gax zHb97<@0GS~&_>{ML|yHY$MuL6=NIo5j|v^|>h*{EL|xPqxZE{L)|35sFJ z%p9r5lSBAY*1a8xOz5DugXZ{E?7yRrVk_4x61rs64gb6GXu94W@e$D;dog+5@>!>eRS#U) zlWkdbvO9FC_-oUJAd@|(b@)cRXZL|-*$xa)w>17d{CSMXQtF`@^U4ij;b;lQ_N1Qk zP?)^>wYa|Wh{)w8tu!8j`XSSe3RSVg=<&gZg!3%m8kgMqd+NP)#;DrFx-0Zi;*O0k z-aX{|K2B$Oli@>aKX#VAT*yqvCn#oJqKdb5@%p2(=s9cK5SQ5!TYB=hdcH>NyXmMm z`WSJwu4lf(d`(;`pY${p%g|gZ7Ii`qKUEJ04-vuX0TtuwWcZ*IY?3C>?ZYf(=V^g^#6|JlN164yaGO}3lZe=YVdL5~_ z2&%$qF(*EMcw)kNc!W!EqK~=RSLbKhGfAeY6Ilzpybsu)acwW!yK#4UW-5~J_?wuQ zwtFjZ^hla@xi5T6_KJO!KKK)(4ZPA(oXYq84kgYR;tG|2FB}d1TVesa76VK;kuM_M z=tk(Glb&YnXN;;hrFiuZJAd}MD1A-g$gMCJsh$l&S2rj0sHV>u5u446j)AvyM<%Fq5w#;)|ABMkl-$JqP1&wa5FFG@pBvOY;228e(>crqRtbB>Cs_zYPJ2F;OGvh>_3~;uPRu+MQ zg@bAU%nhYc(Gn_sD_`9~c2QQmVlU%%`eo=*^A@?SW!D0EINBO5YI)q9DG>HZsS&Sj zQ~cfifcXWdmvymr)^MT-sVoJH8lQz6?)Y{JdKk|m$A^{S`hv`B8-S?zy!5*-{mLt# z;;n8u+oc^`qTZjv{~g+E`8fgn%M3#{2-}c~_NEA*$#5?Fkc|+o2c`l&9=KDLLo_O^ z{CINocK-v`Z_4o!d>*cE_=EM`IDL>a{Bwut0>!{V__ zQVOKyvbzlRH&~Wh-v35>A{3jpFK?GY1KX;2{+J1i8Z^fcmLS?$htGvFBwe`&e6*q4 z@zH);$N#h9z!s)z3G>9K%irldR{QU$sDf4a84SJ}Ag-v?Vgfu7`@jFsgAgA0DFygT z)Ei}AMT5=yZzR$-BC!7w!v5zrgk$`+=Kp&Tfm{U-{+ex8aN)SY&r|=$y7Y{{T$uCM zxFoSCsUr1NVSE0P<-S0(D(*djTE}|UALT0sU$-V{~rypZXbc ztleaWHTTR461+~sap2F9>VP>3wvMZB^JG6{oCY?N_4gs9>7NZnFgQWPM1{4gNkq*N zXjYM*9^J z$gl=K7$igh4uCC0j~l!H@5z1;_E_^ZketXP3@zPMGvj3Fl+hZco6{?RQlSUp)=5l|BWtAG-7 z+^4{DK2^X`$u^mnVhEQ}8AT@U2MI2R)Ri)EAWz08YT;!EzL+atKRqsS>?0P}imkOD ztHe|rf5z;NvP_CgNO-0ezSv07YrrorFUtdSMlv{79T-g*5MUs(|GDnTg);C3j#nbM zWulPm1U+B6;3D1NYRvjl+87)nVf*`j-~qu<089t*bjD>_jeSH<-JuBPz_z{>lr6QI zI5Zdc^BKA={7|6zdQ0@J@zXFlZLc6l5R^-4RBV3nu4t?3_QPGNK#9O^U{N3Wuoix; zh&eo=p0A&l22l*$+|i8B?9r?b)?EfSEj?d9&rgANi0K|rT=F~GSvc>PJ3XN~G~JT@ z*jiN3PH-r@KttRvBGksuB~GI%z_}&3zx*s}$KQln18!k!HAEmK2>9fUL08)p1Pah< zX9ppuHIeWib@ zMHnSLu(?kMVea-iMITN+C6S^44)POXmW6$yHmUpcZ66`pRJlzkRNT@X#*u%@%gsp+ z!_rR$L3CCePZXTzbBkE&&BzUv$KJ7(O1fIar*!hukOPt}Bd;muw#kjN$hx?5mYyd; zaeXOyqeP!JZxXhFkdA22;xzG6OqhMQ@Dq=qzh(RdqG&Mq*DSDihS)RYayN>a`_0== zg}7`!96F&6#?|8+iJC&*Vo_^^uqLG317}Lq6g9(5iA5y5S=ZCVKt|tKa!|?=%p^(` zfexAR)5yn$Jsm6qUmsD0Z>b`_H?uZ;t+*22E@Bdrdv(oSaDgWFV>@_83HU&E>*Vhn z#Pmzs&@AmGT4_Q4_7~ZM>z+CNo7a^cyH#G#`uVY{_@UO4H_lcM#0N*=LXgW6J2pAojMWMC>ZmfvsH=t*G6vyT&W{|4s~mp28K4-8^Z*R0F}5FW_UioQj`-|`$s688Zt%fd`EnYza*OQu=CP& z^5I9NT)pmL)uxop&1Rdt8)y2Ekt(qjmmUtUDj?hlLMx5WFp;j!1AdPhuVUB8BD8$p z3pZ6k(gOhEW}Dq0BuBXTqB;<%w1tiSHA%q=15B4Qpx7qm^k}hC!{dMD63s3mJs|t- z<$inVn{LCNq9%~h(TVuCh6Jq|Y6yXhvb9~@2)r81{0lr2sg((~p~Dg$(NI7jene8} z3G@SjX5eMce88+L(6#0Kw?QVzSQXXuRfsHM$S;`no;tj1qz7S1h>MWmQ;3PO3mje! z+_^fDs-7y}kN>(0oy2Vut(4Q`ksfyedqA{P{?9TFUxv16lt!}^BxO@hGyHEPrKA+w zYRyQGuh^Lv5aa)|FfZE$J#uj{2>MtYlKBr(h(HM>B*BpR1|hrym*D_VpQ7b*YPEQFw(=J zCI%&S*k6+aM)b&g_}m(<0~ig^E0ttfv-GbZ7KD(akIO;i$^^_2*0_1W!r=e;MZC6v zd?}dYHS4SY%|K>UnlWYxk@yG(0`?0=0RDFZH*H|$1PtA-{Wucsq3=D6`|Df~#!PQE z^dYPcp{Ct95l9tGJ%U}Lhs29jJzX5xXb}!J*RsDctUhBj<@VQa{=0BFYNcm?mtoim z8NJxH>U-)>JWT@`0Se*Su7~D|8|2CGdS`+u8i2H3)4TeYSASOXY$R81>8qI^Ng{Xjg}9Ne7r?NE8`)# zDv+`wCBTe_fF|*fE!)WbBirAf9@h%WXquFfI2(iP6u1n+5VJO}w;(p%`bUBb@U-ka z*BACnB-4HyfhH4Aw6r_<^w~}NU{c`txC9DFE0t0@k58=NTtv=5ak1WfT6Q9=eRv7D z_k^a5NHZW-$b(Qv9cGxtki^79e0W+Nf4O*7P8~j;x5h+~aEVXYGjGe_t#srGj~~)eJaq)>j1C*Z(~kBIMEAQnvXl(?C_&65lMeu&cgjT8JvsB1ODaDi zfx)@ffKmJjQ<&r_UL_iCEE1x%{MHq(M|j}iHAdSagz$-c-dgZv@uNH zgi!sJV10p>UF_j2s~g?BMC=`hI&it%*bf}RT?#F>@bYEPMl>PDK7bMSI5Z_XbjS=z zhDelS5HnT;-E3;Yta5YsD287a=k`#GTOO)Ny&^X)z3DE4{)BncaO(b^-rCxFeh{@M z-iy8tNJKOU%#NduN`kFdn3R2aTCN4IaZ$deo+G%K|4sjz_}+MUZ_6->^U;?V5fS*& zQR=X{cV7}{cU*~rTSZeF(gPHFet{6K-dcom(6~4!EE72jGJ}pLOB;#>B1`AMW?US6 zHQo6Q=h#~+!4{SDQ$jkYrty3bm2F&0+d(Sd1V6x9GGo_H8u7XNzFtAxIXwR1TX%Bq zWNs$v9UBkbKGzTbNp#3E_hT$Y!s|THlO-uXiSwRc<}UNE0}rC<%MdCMPv12%8j~P$ zc8|%9jpuwf2Dc#y{0B)e!vl}R(<9m-hL@YQjX`q5p9P9lEjeK)v;6Lz zxm7UFM4qzOE7^Yb0#>5+=a*3l7Y zh8wE-foplWl>~B*&_*vAG#ez;wFa_|bV+n9N5;B2)2c7NWDB0!Zm}%l)yp}fX}beI zU{mN=X6SY3Uy~iX51FQeC>@8+%b22*f|Tw{C7FWQ8(XPKCrn->@{U1J*>w2(?_qgH3sM5z;)?^IDXSLALP2{y$_ls%-mGB z^vag(eEW$`sz!T=wo#3BKkw}afmH3~muH0oQD&IM@`O~|! zcz1PU+rLqy{m~(+KGSTii5mC-nLS<)M~}{<_wS6A!Z?;j*HX{bM& zLPgjE=H*R2%Niy&c%qxu`Red)RUpXFNf$Bm&kXHUt_k|S)(O$f^*g@3(WP|uc*e7> zA$=RTBiuYDVEyruofnRpq1|s}w5N`5YCZvv1|SVc9df5L#7>VBGkJix zpOyEhPLxDM=;+dgr@q)Jx~wP=Io9Pw>v0b#s$CFob1n|Tv5yE}u)Jz8Nm}|cqvM}& zTBhs7&J5=|0s&c65pq-E^h-Pd{u($H^&{8o2Ss*mye*abl}+=F)JIYg4ns|G?G5Ic zasrrLpT2X}hMpyUz6(A6*|NhJ+JT!aD9wUTNPzKzdYDb)OcRK zO!)(UK2)!Lzdixsy0ceUMRKFO!7!R8=c(kw-6wE?kLw^dDcR%p3hH&z*e(4vv7QEv z&Zzr+-r<}+>UhfqWotY-tTk(M$SIGbe|8p88Q{I2KCw#g(MTr){kD}sHYW{L_DWe3 z2O6uBJA@vD*u0EKRHZ%n!|x`E2=d>fKI=;}^a{FJ@)hV{P&LGn`fkiG;^_Fjcrb^* z=b`k~$753J5l~+CEMIf)7O#BUO!{ekO=?@2(XC*`yzvz0q(RhKSB$X_hkox*9}(n2 zP%%c_gm>{kL@1lFpf<)i&1Uadoh?pK%x2>*s*`c7E)9TMZ<@CfTEzmpm-0%~WoPz3 ztudBLr#rJ0cjJL>G|%J_TZ8H`EWFJMA=_t*e@tDD`;9`ii?n2V*qFM^g1~N}nR?IN zW+DArTS5O{+0%adbs6aaL~ZxJi03^C-4q!bK3s-kcGDt08&?sOt3~A2d-Z~(gSh+8 zQDQC^RKmkOcHSFGZk*MSQR814(cj(UYu}dgm0bAIQXdM9EFCr}M>`uNMnc?MDWIK{ z77cPyAJg{FA3eF06>XCiQN~OnsMP5mxzG-E?;a9YZ%TK-Zai~)E?cn2P30yI&*@lY z*IPOeDBwd@-sIbN?G12uch@Js>HC9q=$l8W<~P{QOc4zofi4*egZsh2UfnC8Eea4U zFaJX@O$Cjl2F1d8r3Y$LQzUsxW7o%lyG|3eG zYdNBw0Z$mbR_pLl8ufK3R3Ms?I_9GdZSqzM7u^{2AQB~6y6Vd~Wa#>g$+++1bZ8o7 zT!ZQia_G408NqCPKu#5__r6N&4j;{66|49TYn+G~4gb#mjz{W?D@6HQ_8!vrdneMp zGLhX34h$By6)=wI!_YJ#*!09KtoxEOCyONuNTC3ZN+8E%zPD}o^lvp-n>}DSMQW^Z`Fs5rj3vD}TQ0zeEB zrd+H&ym_jmw|pb*Z1}uDXLgT3KE689b2aj;{-D0imSnWTVlA^+FP(W1Hgg69R=Nua5^)kw`s+b$C;m6;KUpo#N| zk)Fn?b+}&sYmxP}Nujq=a+tZZIQLsC81C>nAwNurP~Q?S^2toS%=oD2I|vM!)^Wwj z5dv@!6LBg+VJ=u2~ zMXX5%M2Bfbn0Pk+H4ni8A_hYF>)dGhR8x~hy4qh&J(yvDRl}K_Wl9OrAZ}pf;w=1q zwJyzf>RvcOOkv=563%Hxm!s%Ds5NOFE6cYLXkp)Rzl%XKV_O{F zNE3Z=@>v$$Rf|Fh1h#))^{#>T5?BN_jURn-Hnrf<|FZ9NJ$`y5 zqt|dMj|V3$x@uJFIv(&$_u_ zSESoyT&0UHqR0#o>ZD)(0b{lVLg8_^mfw*6{Dq0j0Z{ zb$Cgu9QFL9jieC@Buk`j;gafA^+{~gQ)!p8+EStf*`xjCA-(YWrF5SzU}R&4CI9s9 zZ=AI^omwx&a=OXr9-=-i$*b{0Rg%htvuJPVb4W8PBXWc3%g0X}8G;z1weCxek+`=& zwkUi9cCqYYdQqBZZDKC%)7Y%wI8k1f7HaxoD#HyrE=3n^ zn+z)aP87)J2!1F7ca8wMRa`7Lb zc6bLLBD-Nzym-oEHQL>D5B9~K$4pW#P~pLx@$4NBY+Z|^%eYI=L=5_ckpJYaSFp?J zxO%ALM3}=W`erB#-C;$f(b3-MStxaGL%%=0b(nL7I6M=NgZ;t5zA2uqWkCb)TSrsgw#s?wwGmlp;c|a zyfrkL4*eggFO$2KIX!&VnZ$K3ms8Pjj+Jhd6*2NTGoGc*cBO0Sy!4W$Y|!%^zf`S- zOzU?1!B>sXo&sH3r|Dsaf}Q;I;v&r{vm*BvyE{6^Pp8=XqJ6Hi)5`vHFU`*A6& z$j=suoj40Id5&VyX38!oL1~88?WXsm3O6Zc`oMXO>jseN*48=46g;WogpF_e<)i0tf6~w-&g>o*=T`);W$6$-Gu$MH^viD1lKTMCBXFA?7g0MSnhjI%CFE9_a%ZRXfia5c`HKpk4}AvGTIPfznC|b zSw45ZjkC${PB@QEr;6edC!gAe>7RThpFzzvdL?PJhUO$=I;l^7?`>6(v~#`kcJgg6 zx8hBo_4Zt(z8Q8~UMlf)wsN_xDSf+Mu#w85@na^vZyX551TbyI;A3eK-=*I@s%3_W ze)WsxzAaZm`NAq9`C=0PFLaz=M79^XzGp>w>KFOg9AZ4j4;&VJl|?mO`p;ED&+?c?b&I3Wn^|*r)Q=7o zo^9X3=!Y)qHtok|YTuKyl7_W!hEAc?;N1hHt&JrgLb^Ar_fCYrg!On|R?(lxO7`|S z-D+t1fx7BR#lqdWR5yDV#zOZG`j`~6e!#IRvHQ^b>p?twAL(wIlyxtcB2{YTm0%Tb z)Sihmhj>~YzGYj*PZja>45HW6BCL842XGJGgf?!&PiO9ils||>?3w(sqFHj z5N1wxa`KI6Ma?DgGxvX%uKO+VG=(dU*EdX09VsmMQ6LQ?{Vc79A0oDrm@8G-T!tHU z*~8V-#&SGo*xwdc97WZsds^2SSwH?TH(h`{t)Yb@ABGy)C#&3IIiTCD;+=o}IvNMv z^iqg-J-pZfXLO`UlQBuyIir4>RtfW=43xIUSor*!u$-hn2YUC;Y=9Uqn{-x;l)3Pgo=&QhY>;-7 zz9;E5qq>rL%0^iDvq`oW*jHkSK-y!3hbY!2^-m%Rl zy}Uf1-t#0pow6V&j3Evuu7Z)04v0vz(AL>KobRWJu@|@el9=~u=A*(LSiQhxy?lpX zTK(!a@)UnGj!3GYj*k1$Gw0)GP_Gj{CG!1gy--z4;!x!0R0T>u5dOp2@Wl~lm%ETqA z*_OcEokLG-Iv7K`cJKGgRegvjN(L z2GsFAZR|nEg`DpoDl9-drA>{W;vZ#QG^k}%7NjLdW^3w%gFtYB3dj!cV3!f)ck2BE z@?za%oK-8PYFOh|k^K#s{L&ch=4>sSdH1x)lU-`bDq)f9Z=uSR=zp-D0M184NG>4v zEad{r9wXBXr+QaJKwk48A|5$hw&elfCQc%ss4N%#BdPPz@0I?{uaK`xE%6oH?3}e6P6o8~N{YgD`z)3d`RN zNat+W9r+Kg2Uj-EEvyX z-DjA$IXV^`mXLkW*#k@g9*Cm-yG56Oljk5DFg$VkU7!H}3*gL&BWw^8 zr+7ic%tj6;0mW3qn7!`?vA^T;{oLaJBkRrMp?cpx;E{?VOJvEGEr|#v>r6?>5~YR8 zE>w218x%6xCOg?GTZ=V}eJ5F`h788OO&a?)#u%Ra_wUei``Ff`4Dke+7Z{gJmHgky&82%)Ygfz|OHi<4hOU#TkFFa~I}@b#r3UOu0xa|T zhA?B%t4pvgv>`Ur;@JFu`7uR)kn2b}n|!>)n65Y{C93$`n;M~hNT)z5HEs~e+4%0O z%4N(*J+f5qUW9+bp#iTCg*>1%oNEwZlgKQrc9Vap0>F9)t{@I+1tVKRt zB%tKd-}LMrIu5kr4MefNgCHJtLN_wVoY_J)Du}7%);!1xMp=GmYOdMqajKwBXylW- z7f#J8O6CyUz8@EY*>2r{@g;de`7j4>7=LqrR9ccE&?sZUwT#6s-7ZxKVhL3aQUDsF zdCwYjnqIz_N_rm5cy5VEH+bX0Z>XuEVJQN=$8%vU@2qd5ZZHRF$)$xp=+#IIjJFA= zzTISunau8YAE8xr|AD(YLt|*n2va)USiThSIb7se3F>We;&tVeOB$BRy{_$SD;%vm zAUe;Y<7b*U{RVrHHr-lxpu7@hbI1KfQ6GY^?G8v8N{fIDFRT}JCpiJ;$>5?P2?_FC z$mD9O`6$g9WUb1ivjNKvnnxdG-nzWa+PxqQO&F95IgegRu2m&T6jr8F0#{L~{*pqA zy#Atg71EOaqk#spSy=)p-2T5SPe8f}=o%D)MCnWft|*35A3e$^`_}ORj%;V8+We`l zGYBIpipU2;7J7|~lotF0yn6`r-BX|rh2^u9>>1?xbpo}t0(Rt_ZGu7}4RBsyYix*v z;$jK4L#Cvt*F%HL3v^RKaS?ZtSHVUOtMf4C##tC#O|AK7$a zTzV+Ii}*yV(b4ha6S{YgEXM2St>^nbfyPi;8dw>aS^;!L;h5{R5yN~Sm**1n(wC;y z9+!e1jVV(jKT}c*XoN#RLI5P6j)(HzmZUK?KF@dh`Z5Z-S#us6N&4yb2=p8wk&%%j z`0fDaiSY!BhOurIT}ky~Q0NC;39XTDet6;t)T_7TO4UXA^dtwcils({W_3FcJs{FS zLs|`}hCOtiM?lxg-e3xqD|M##em45>-~w^r0<0EY2j6L)W0p!V=FYUdF$2pQP z2U8`P(<;5|;laSkmC7a$<UCRk@yACgSkd&1 zfr6iC&=q>`h?<5!-D4~h0>AA8Dryw+XOXb6MBki#QIg4F9|iOQUXA3uO5MJ=^ksHo?2a1@~KsG5=0;v5UdDpgb+dk zA&asdqN_X_mYnb-Dr$%z*n z1B#jv$kL7f9^FpAd>fR`QaM2fa&hcB(yyq(i0c*ZK;XFlpyE-IG10lKrpS$qFsz7I z6wW=YfG*CbL54umSF*M8PTJk#(8|$QuhAm!xJ^;_jvF4=J&vuT^XF>ZgVo0x?wk%1 zh56%0139@@o#}Sz8s%XUTAj@-K|qCJ1lxzX&;@mcGnsYa9v8w~PA_7{p+BJ>*SKP;fICfARGD&ap+&LR1Z9Ub35OhkCX6V+on+8hiA8Rf4PZNp{ z5h;^$b+y>~q-Hl8f5lwmr`Y$RFk+h>5!E;Z+vCcZQlLu{B!1B?lJj2cJ`Hn(UGRMe zBo{#l_v}~1R3`OK+but@eREj*8!rlv0yU~;9|VW6hQllFb9P?j%s0f8EN%n{x_>bV z)NL=nAM*MebJT@1$l0~5rJE%$OeJSylZTG-!uuQR5toZvH(~sm%a?;>>6C&5kNAF< zw4z%`GTh;>8@Aozg@iwF82ko0xF+!Rr25jHtJnV1{PFftM2}H=Kp6q6ojLlBGv89UT_oI(NSaR2ch3ubwVEwloYf~1u#r!8H3uv2)abpJg z?pDv0#`bRKJ;>{;(yEGLZ^sM}$PI(uh?vOPfoJHzB#Z;^t>}rND#4GJucysXwEq+h`lT z5T-!ooKVP=vrWIj%**vypR1s42V!n{!cTMP2KF#}a*)ryd4Frs$hVKzpxy^6XjK=1 zBgT!Wc*xJ|a{J<}m$-;ZuKk9+VCE*UD#5`OWP{6Qa z-TH>)EXY5F7*}gLo;*va46&5c3+&lMwyKamUp#gs&cLB<1HD<_%GTWB4137U-Ia3O zkKJnN?V*RY?J_nck&wx>dfwa|7~`{WT3_jMDT9l8X&GJRE0SpQBo7R~l^S{e4Nq>7 zRLG9F^oC&tyGD10S&`TDts_I$zCZsv8%Nr7np%1}c+pY8xF@yYnC;CIp6Y$73OC%c zo#z-A1S8FX2Y&PJ=YC4)4xrmcAkpR0M9UTVLl*^CPe69P6&I3FEGkITQSejkQ@J^c z4%DLY&RN^3bLDo7O;t`u*F36Yl?%}nPIWDDvKu(IG*&G)yf-C zp9`tj8>?YQ4eZ~~`PlyWH*C~C($qEOHJP=W{<-4Rb;fV+xP&j77eG={OIyTSKW9)y z1ofMSvr5qTp-TQns&dSwW~;qZf%{8KPo$V4dD=(E)7z@QN*$ML07BH(g8ec`UTXaQ zPDtud2D1-Pw`nnlMOwuh$#uT!V7SkyolnKXdlBHgsr{A8xCjjsa9*P4FL=tQ% z=EO*tn%W`ilu|1A8BOw z!b-A*ub2QRWo4F=w&t^FG5**NCRY| zDD5+bvf?}tU(>;aa&Nhi8wNmjW%pg%&Uc$GC!_y_&aKHqUK;0iv%o_fHGqr~7YT?r zwxF4N^u+ZQzzKb+2|U?&Ei%=UocVre85HOk*E3oac}V-gyfahkPBa3!W5S3;&;7C0L=X7^R$IUfk4K% z64vW6G;#0gcoBCc1GsnflP?zo(88d0EUN+|eM)hxH#A8M45%o&|J?E{cW`{i|@e+9D48Y+-KIspyRN(mf4oOZ!> z>jX?9l~?Mg{7}n-UG?Z4i9EV(Cc?^NvwD9@AfD)AcCmE!y~X*~H^Ha=eK)>R3eBVt zp2K>02U}-`6~Znv?$eE~YHqLn%c|!#X_xNs?44wAc?426%o!kJ+A|7Zgd)_VJrIOw zNv%v|qx(hYa%&Np);YD5d9)Z&f$l!5l{#e5y>MkIfFJUu$ADK=Jo!NNp7*5`>$J_Y zy>qt^LF+J+!xK0)I`ghZF53^2K64bfP$ObmRY~>IR0{0j&DDC&@h5y&Bh2hzfpcD6 zzmskue58Y{VY|m0WtB9hmk@5`<@NV2WM}&A#F{__P|c{I%G}tr6mTYp-s-R&LV?O0 zgoG`an%i$$+4{-nrwaOb1v-1rkDtz<;;X6OdKON>JU@h~sqH;+g>g5AnzEW+fa{!oypgwjz)T~M8rOE74 z*rCB_ONmXz2s-%n6!p-LYH8$_JE1^J#_+~tMM17C*zz*-@$+OgTC2zHSdF=GG>rLa%I^MIbSUL;Q z0Ga4_E2V2x8zm;}wGhn6drO&3%E`W9d_syN`=q7)+pTz9*FVQO&VZCzz60X|lG%Y4 zQ0YT=;^!~&W|GQ@3iIkC7IKvu(i(#lcd|k2xz^LP?qq89VjBCY(t+AXKx60wspF0R zQht&@1SkO={t1cw8=vVj6}T^6I;d+`;ao&&JjHw?^c=f!EqnFG5m5LYs8iDWyAX0o z3ZcSW>}b8^@yUqG{Wnmdj6qq)1(5953;uzMqpvmzPX29OTdxjv0xZqxSMJDT5ib6t z?GLGK1n}4o{-_AInlyP6lcj%-lUqQ;t+wLh%9ZEKFxdC;xCn5Qj^iGDCAN$)X4uge z1c$f0okIC|S+Vb0xn{C+Z{$5hL;Zl2M5VwcLc9a69Ctrublr{jg+_PC&%ho_iUDNzMyzeY3o6$5 zl5I;dSRSwOs*@zv0s?9^Y-~$-00Fidxvsa{LEJl1j#SYsG!mQ!b(9VkO9O+;%l4_s zs*rfp{RaD#O2wyZjB=8Z`j%oE&vL8WmkxP95FZeFP{DgvNjKwDe5v33VmE0NiC3aH zXI8c?STOs;$;{0GKLN)uBfA)zr;Y$jkBP_n&Sc zW|ces096t9!aW|&d?he*{0Sk{t^2~9qZ!7f4ysL0Uuh6(F@8aP`Ey(xaUFC8C{f*B z=oGtnCYkQ6IRh|UA;}ly0^efez52m(PgtBH?E1m&{#eu1Vos6_iU`bnOM8L})TElC zPLgrTi>n&j3X~BnhKD6+)Y{x#Mdjoy+Q-o!RM=L%8b{W%+$UXSl;ca@6lZO_rv!0V z79D?X1J2z21tHR6xKSq`QQ=g2M_W=oSXc`3cjZxKpy~mlDIjHKAtov^Qtf@F$Ny?d zZMQypuc&{)#DH~=P$1+#e^13@fS^y;b;)P|Gk?fpe-NLRJKkNgvb6VVSn*aeK7D+3 zN1n4p5mqV)@oHc<2R{5(+tm#2#!x)a6>FfrG}~FOs@)wuDm=$K_ZaQBLMwN?c`-lh zBuO@(AbsD>R4Btsq6!!CxaDInatqBr8^`1gS=HTSvV1$-aV>5^Ah zW{|n@^#cZ%5Vqx@F>4l9bn7Va<#$UOPu$aNmJH6d3+CEN4W6~I9F z=)?7P!>O*n!Y!oQcS1pQ&e-n6In9AWbE_pU@Eg2(I zLG*+T&sIer-f7pQK0-g6$uPP91X+?&7bC!a+~)X1wYu)qA>)V0{ry5!MBC-HuWq#a z6~v!6`SJLyVEKS(E9EK&z7j%1#QM6de)J(1v$QO7qGLpA6Y%@OD^;V!F3*Tp`g!hX zfBpNC55ZI!p^dJpDStUY6uo87Y`g3Uk$@1%$r=25V@~7ED=M_5!DC1IVgvu&(RCHC zeNpv^bbUKQtxS7l-?W)Sjdj`#11IV4v0VI4p^tz&{$`ErjE61e24f+f=&`}b9fv&U zG~Ud!J(wX7uKd>i)3YeD1w#(!FOy!WanaVvl!eb=Z;0e>gxXkU_?A8H)*)|G|K23* zQ!3Bhi7f;u4v$!OQQTkltYPhS9HpgN?q83dv`gj)vhTc@w$hJYmSA1~K{apDgIA4O z3FFkG0*%01A<6lms6p;Qc-6D7QJ_4bu{+~*bvt;n4@$B(MokPp@L%G$`T&!?&hRO` z|Bqg3oO&k=6N&ZCsS)BCGG$>b+F6r#2(_x`N>iRW%XI5UHE|^(9*0iB$*IwZ^p(k0 zm_g6lur~G}d4Z=ub3&=b-uN9Z9pK|yT*`K6CxEkW6~6ydSbnm^mSFUd%0rG%9l8?k zv5dl2-8Q?DzSu&KCGS7kr3q-s{@p}l;exrG#Q2Z0#DR~}9?wpwuay)%3~8?A*nhRG zUSShJqzf>hJT^9utY_26k7z#TrE@R=-)#R-_kQS@%AUsg2zA&uB-5zk(a)J(qO$sf z5R*t;%L`jHc2T3hPqjw2Man7_40I)gV-u){SIUY5D~-uagmos0`ru@^6;h0 zfbcF$;II@O2^LlwnR~2Y-|1-kI)#=_C0%*0*gmgt*=}p9np*KqQ5Ix7DatoNv@td8 z{k%3~Y0G9ZPhst_&cm)*75%YU`vCKj@ytYOfuy0f{08bH!l%A5l)vONLH6ic)r7{R z8E_d^UpcW;4-a6NNZICVu#l3!marLaWWckWO5eR5+~^Xi_hItd_h76i$1gTd`yFZX z2fl(=B7BRZJY-VV6&~;;pZX}D5K@#9oLN*l;ql<#>nvD+W;t=)RM{Jj*srlTjhSsHqKQKV``hZiwP7kH}Il< zj};7i1C+XgEywDo-C3IHv6RF7w88SNTst=g1@z4oznQ9O^5Y6q>DE@_s$Vg4!$}R) zd~?1HSV`qzCC!EHrkWLHvP(V8_jVW)PU-Soe zE928Vc_{ISS2R_o`Gx*uNUs|rMdYxZT6F59qAR~?y)Co4`hsLmQX7e$gw$iu4?j`j zcPi-m2yI$UPSN1kNYdiD7b)lEqZ>|fm{JhxeQ4RKrgl{+nCDykG_SpFF>Py=f)Dxe zlqa=!C5>M&USYe{P5b5d!8uv}CR8#xYVg`Lb+ha2^_|}?Y>q)&YTm35&Y z3-Hr>t_bWIfT9S8>0q^Y`uPptafg$udo;oX2N!y5q&*O;{F8FimJ-a!$-`+VUOQBK zk(J@x+bZ?a+W1qdr5|jM#@0p)P8zq<>LW5{P%ZHDcIlQ5o~@$$SxVRq7a=`9a*MZ* zf+{>IcecdP!LU*OvRKPYofX0+wD9aY#nRVjJ!Ac??fq6U|K#I*0b9WI ze_*_E|E`#@BAc?N64o&d?2i33$~e;@Hai({Hg)@aqRfr=5>Nz@|3Tq=hJ+o2Wp?lM z*AIQf^q{`yQ>`}jj+Z0@1WuHIIDzEzFiZsTZL>wl;ML@zTO(o4g^miJ7+)`^W<3FL zyEECt)(t94lY0OPbG@@Ged*Vk<5I_e!5~GP)MX#XNLL$fOI8mpfSNVB!wo% z6bivWwYy68yMj>Hv^t=s{QWa_t1xfBa71^P{@W}S|5wN_pP%(P=Bu|X%=}0(LaG_> zn0V;!t90@t7I>pulE@35-W~@=@VgT4w-hLJO+IhCbr!CBP7xqk71&8Iou~CirhHT*U*pQrL&+`mh3|X-@yl!PTf|fp&cP? zrA?#bJ$A>4S$`Bu6m2nT84W}LXsI)suwDU8OGy|$WNs$_TrYX3p}U*3se4L+Z<^e_ z@fUzjz+Bn2g{ly_bJ(n2JT1|e^#cQe`U2_>f@GnqrS)UAgJ65o0E%Nj25bvT8Mj}d0H3eU%bwD-%OU`H5G z;~v2~@CuZFz%su&rhxbt52`>-ivU%D`%yc8uV<;5*(dHc&JpYp4{0{c^)=0_6kxlJ4^`XGTq?FFu*)ZG^8@;Umw% zwjJ^ne81E2^B>w=pT#UNLd@d~9>C}eV|E%NfuLZ~7DeYmr~W7AHdsz)1 zK&oyv-k>Krs<`Z|vN%ecMnqxu}e>Few;>Unzr&Eec54U z%Ap5E37^xyXRDFK^4^0aXFN%iwkQtUOA!zhe(EEb2o)8&o8D)gJ&eujT;x5q@lS*66_g=3a(HfMB5{03 zpAu|)7!S?u_nZ)Oo-5gz%dF4-@2OlP)d~_Q+lzLTn5ja4O`j&TjxXv^Us|U5FA%dA zntEq`ar`J+_i&A7ks;UsI&hWRSMeH@6umbbjw;F{WWbbSN!|fxF=oE4Pyeotzw|t8 zPlaMBNuNAj*Fim0D2v2)E6qzAGBfkA36#gN(l(YBoo&jed*834#!GpoVhLdT0O5Fe z2cFsTV-PX>=P^~L;|43+PrD%gTd{XC#{V|EP*MB0yEv)dU(o?$uD%iW>TPZ&53^rLLI-HxNa_=;N+gvQ=d**&*y0ecS z%mwZ`8=rFj5pt~MG`{luj|Xy=nm1yeYTlI-IX_qX<1#VCvgeUezx+sN5vFz!I-6_h*01R=+B^XSB2^7~5A}SkpPN z%0%aZu>3FuVaG%VrXvi#zH(dc*Bk1d}vz7^H7vm9WGFc8{SUFy8L zZ!RBYi+@ZiP;)cY@$nzKy&}LN+rM!_=w9Z-IME?LpU_|a>gGKDu4;njek*2aTr)JG zMRNIfmB>xW>tjD+&58%Dkap#PM~eg3Gzpl+k+WT>E#gz{^ZU|&yLe~A{z*Ej2F*^I zTt{oncsc)O=YtJC?Ct9fG#JBU(o?&8dQ6wP*D}S`HF4OmSMEnEO9gKW725xX8x7nV zw@+rxh&Z;%VH8GiR*>*ZsxRuYQvDzlb<^u{{-uvve@Y)xrn!9T6^8YF_S~e{?1NcV5V%vBEjaJ z{mh~(=!+a99g4mgQdVV^0oEH1x2r0+`TEcEzTDfY7ZmSqc5iU#g?aRrs64Hs!ZY^# z3H7FLHV4wVXVX$KtU)=`yB)jr>8)0`V2Q8S6V}HQ3g#rH(+qG<%5F6Vgf|JZH5ZU- zi#qC#R8KzrOCE1OVLT;*a$+K!ynizXreHlHl3>QXh36BljYteDrulgrzWDKC`30f) z`-_4rJgqpUSwvF29V@FXrz*QMRa9I+0 zE;6tAb-O?&)=7JE!vew4Ya*$X?CRaq4kNLbos$G0-F+@o7`L5q|8L(C_Q zpDvp8COD;))|b0Q8S@68a;Xy-z{pCDzZcTGzq*CIN%yMshljs=PSxFgQ#YUcfhmM~ zSaF@mRKxoC`=T;OSmOA_6K6#-1~IZs+6JeikNV2JdQ57uFW`2hPVIYlSjuuuLrgjJZ6^LH!Q^fcS-jyOLP?pWht z>Sd2NS*%{NU0QCZteSn4Ci0uOUpj3%8lg~`k#DYGPQ?{Yr!(=GJgww8oS3oiSw3Jy zJoziN0TCPUOP1~gOt$yme9({3S@lCH5sFo1Gj;Ah<8{a;Hg<-cuQzag;_8I15gp&EY`nMjq+zG3 z$P`T(x6+Z1pe7i0#uR#r&ik=s)bd=5_J5Q8Ub)RZHsJg`k9MjU?YxmBwJv*F{flUl z;Mi1JnyzAltnBo{)pb^xS;_e;g6zHSlkQXQ)9y3wv+lWuojdvGHnLF0spZuDD_An# z|A`{^!piuRs99Ooz>Z+vquG*dXGg>HiII zgS-5}%zOL$K^Wwa^7iVp$zrQ+3-_S!KXmz3f4Z@qVkfVi{8uGiNdJ#p<;?nd(^&Xi zLb}^s9)=DUm;et3+w}u;KNXSHuyx*r{jUFA;dw$~#zf~aGtE|;VzIj4x_7l&*O4Xf zxI@t05v^28^KYXr_EmEVWi#|P^)YQOq9(6mTpVW1vgakazxb#R8nE8vzt%yg%*#4; zM^si4FPVv5wX{y1Tg2wXV|Qd=^HwlVG1lli@rl*J@5z{v z;!|p$tmvR~tGlDKlax=jEVq@JzU zQB3_2u1PS#<9Jwhu*r$mFKqRFzdS~>)E}qPjkf4YQgw&1l7ePKxU9;0DdFcuC~p^; z3$=O9U$#x~kC#a`+_76L0+FanFxE>cGC)c-2bNUn`Y6qOe~ISgHH@NCOY|>v-jAhH zd}ycjFR$6}l&|;x9IG16?K9X~|Lm6QuZD}0pasZ_&zA&b?(xq&+h~Hb!i93;^JYgA zuIosK?bO=*!&$=f;1wx5YZ{sEnbcj?S~aaI^AzQYqK=4GJk>d6Uf;R5VVxkqIiJ2K zy{!=A<;&vL8HKn)p|~FJ)mksz?AXmm{>VfGvaGLf=j{4d+m;|o&DV)a2<&(#7K3Qd z{E4kW+{2P@I8bS@AOZ1x^XaRTVUB!3v&5>`$l@hRh@&bDmTV>H&~bJ0Gv-9&+7s|n zqBg3Bto;L$gQz*Z}G1)4vV@5tFp4(@u!M&g032S`Glb^A@4&7m0t?63tPR_8W-j`Kx z|F*QN6h4C;2Lc_euZf9h^TEX*x{i%pRH(%$lO<*`*^oECMkShC_EYW^nBEr?&0nvY zpF>ZObc%`l^=8LYw{(oaz4Kj%tJEf4W&8#)^swCEuJ)~0&AGQzJzo&$q>D^mx=yMp zosM$CVXSqOjlJq9CLh;NfG4+5VRjoJ(%cCw7L=J8TpxA$L$>KKJlT+Cz-?}jBJ4N_FnogjCHup=}4pBYD3=|FpIFDdEw{1O|OkCoxn;F zD)Jm-AmzjtRV*f3u?*N3EXQn+QQJ2OEU;uju(oU)UDkGYcPXG-be+Nb@wnq&z5q$d z$L6D3O`Lp(NqIL~hoSqbzp0oKwaUZ@G~%Rk_*HJbTK&0mfdEgoiuLTZpuJ2?J{mMX zC*CVgyBz$cibA2RV~{Xu0VA`{wIO8j-YAAO*W@T^xtEnuSC76izUvb`jd6Sra^Rx# z?jH( z!D$|Wcg{0e!eC-ZH@4zHbVqI@&MiD8TZp;duD!Rn*9^1Bz^r>^Cs;lsC8bJ}zyP~w zdNb>{xVYm#`nM==N8pZ!jC6cDF4DwBmWHGS3S9sQ8c@#(k1=I?RP*59qr;+I$+_jwesNm(_LTBST1PJww zh>o;PR;J%Fr`Q>|lc#n!`6v4ajdco!vaJVesbbUeft>v-hEr5Y{c@Uno zoy{worl%1_ndZ37-S+{GLf7#g_!U>mHh-p)?R@ppT7XahB7<>}{FnTXT);m zwhrkgultfVb$ICx@*anF`>mbOY;)rIgm&GXd(nj$Vx%LbA`Xt)FkeyY-f6jwLJF^LPz&Gx0UfXEE*;k8t~Boph2y%bUdjQwQwA9hz+ZL&1qkB4n(P)%}W-Eudfb_h!jMsb_%CNIkP~!vF%TnuH?St{Da=iXcS)Cx32G!j-<2a<9m{`;Qe`1p&X^H>y!Ga z7jpcS`qbcD?3uuso)>|0uxCPV=QR&U$?EQWHJXXv=-F~=HFOR*p=}=bQd4p^(4Qaj z=7TztLgdvs*TBZ*HmM3Cb)D)T7i^yy{FwA@y|%WS*!kRi?+Io3uUka$eSN1UBoCk$_RtO^0`B)%(7V#W;M$U}OAbDNHz;KqoZzgb>R zV3C3`qGK5lo$5PG0{?G3AJ?>FCvTit+;{~1S*-K)bhn*?v5? z-u#Dq;wS_Tz@*Lud*E+)q;JY25P^ID`_Tkg-u3aKr1zPb2m@eQz=e;$E7L8!?DYjl@{*pGpD+dSOJtjR6N8ZLsf|*se2wnT(&+hK-2fC8xN&jb&VK9qO zC1bC5GV{*8rvGx8hHFM3_1#!g(Sl*uMY%FO7H{#Dg~RPrg(L09!9NJ zb#bI{V1SF}ZbkMLr{S{ac^5LW1L_{$2w1)*oT3@}bab|%YfBWEq$Ve3HyTvM!m&sLv+18eXq z-u?ZB+Va6zS~jj*N`V`j@b=7j>W6k&XQU>=~l>i%jo5 zY&*>u$3P`IfTxhs89p;l1_2l;-Y{cIkzp}b1ifz!mKAW}?ciU^mJet}&?$*|U*#7x z35Ft;_u#FXQ6LbA)n8|Hvnvt|#}+K$B4z~ga`n;x<#Fab`H|$TIPZ*k!??seLHSTUp}0tEq3#5EQ*1E> zof5Zko?*V8?MwMs#q#vs4a3f`^+U4~V9~Laf!Sj5Aois-LuE_QKw4=A-TKc4yQ_;= zy~pd(T15)RfqF-mB(z#h#gSKW-06x6-AL?+d&7X}4l+?vHZ|Cn*kkv;Tf6tU&=#-~ zwef4|P0O-dq1WI`H1^dC+SEN#1( z_$I0u3o6}Qko}4mB1yOVu6tgye`6DJY5f+()V_dq4Qq-YtwKg+xc^d^2*kMr<~HuC ziDW3Sc=Sb?Ry)aC2r@RA+X{&t*SE7Y8D!wd%`9{lCVq-PdNAoq0gS3Bi@5L5nOlT^?P} z!$?2G$OUi8QtXWETqj1iTy2u!M(Xtc8hk_QcvTzVJ+7oeD2Hlnz~TY-QT^CY znQ1`=2pU|BLdl3^j7NW}$ExY+h}{bKi=80smOGE|%kp!e_Fa1N$y3;)xy1m`stNuZxGphd=_q6|EkY9v zSzL6qGkXs~ezvDAjy6t7uq~PoZFH>^kf0w?Y*;*<_`!w3XFGf=ati_UfH*ly^;2%Iee1-iO z$TF+mFW7t-yOr>=;&!UyVn2rU_Sv|uv_B)ug(Rnk_Q>+=Bs8#kWU8*D!BC>b=pU0e z4bCH#s~WK^8NmKyT>^^+d<#6~zXWd4-fJ}2E+_)NUbb0;84M9>Ajrvr+Dl2<=hX}m;_eE|61%)IY zwI8A+EHEtRW9$FISq22kh|^Fy-#O}08pRvFvZnICOi1~x^61t+jTF8^a+fPS~3wV(E?hTc~Q ztF=S?$-YnVAPvx-G{}l%B+;CH*Y?(lrJtYo8`}Haw60`qp41Law~xqFV55@I%C!T& z^On#c7q{GKl@*=hh*$`Go!ysSdf_>q*=m2n;z}^tNPEYXTA8S|sD2)yXYE?8y$=~b zD3)p8-V~WC&xvQH+M$DL(A@g5FV`lNWyR;oK6>~rIQk#@_v{&@(N!F)=u|pwT1+4n z84azE7Yz+W>+T5HxU$kU924!aBQ*ak!dxa!vll&i+VHJxx13bnm1O9YdTmLFVO~nG z3H}^f@Qc=AVvYdgAnmJWbK>dU#CH4PnIm5=DC_K9+#f?%`aOjc5NDp>+p4;~H~b8%KEgC&R0`SA(+Y`(3m+yJq%iqXfo&I7w?M& zKs!BSD*hBPQLFXU(mi|RoufZerM^@?)>*2da2X7OZTlB09^x!x1?P#bOO@Q`J6~L6 zs+w*Ig42^Ks6-IIUPqVVA0q_VmlIz4>!UXRQZ<4yDRX%&_iWty_YN}*gQ>yY8}T~H z)@;{V?eX&6UBk|Z(eXHonnJ&qh_%e;s&F_1*?BRO8?~6m(>sL=*S6(YS7-fn>)xKuRK%3B9uf&tKRcMH>%o5 zn3ozLDaM-qy$GsCOV(ryktgbAl620l14Qhda^kNfdkmOL{y<}`ckb5zxW2xf2A@7N z+U}Wbj>jtaI~|NqhapN83&NFRN5cDp9E?L0wSumpYFH1vaqLAwg)^De=kUmLmBqb} zlX5a!D*7Z|xR&NZT-+T4AroW&ig-8j1)*cmg>EQ0{-`3^ZN7#&{r~^5J0taLhX_ezspz$fb0LyXBpF#4@BH-eZ>L} z@zoU8c>E6&8kgGkw22Ay11RWef8gEz1EX(Kj=F<6;`u*_X|Xt5&J75x9M*yM=~V#` zPlC_GMgR`Q#RPERampnRiGA<}DCJcCi6c^L`NaY}qp5oG;Rjzc>vplA-M2UMw?z7g=m(U$_L#IRCNNUb)7@=ijH^c$j~$&3R$0i?-YLm8{l6bW$W~;^T%2|bH?AwGr87L_ z$TFiV>1Q|p!(8RF5FA6Q{&s8Ub#_C%A>7cuuCe%_ZJzJ-&L+idtOXnfJ$q-_t2`M% zU7>t0(~9D8{$vmrvuaC#(Baw>HA(O&L5swZ_59=OeCSx+oeyMXV(4WLMgUIk z$+4`cf4oEpz&(sT7(>l8oS_aSejO`n)dKk;09KEf(&e%ah%a9G8+bxnYg6*#Qq8Oa z@+mr0Cf|D`e-R-pVm5z22~}ydMD>uIg^@iHk_|ieV)c7DliSO&5MZ}>>n(1m zeI*+8Hv67#Kn)B6v)p0*L>qP;%djk1UEi2npWU4E6@84;XJ-)Eco2qtj z|0c-Wi`V5ARmsd316c&Yu=Acm*yy}$`wn?)_24JkiT1U2nrX>Qf=IYX0P!}CNk>u^ zJn`ppvj!w|l^`1^F3Uhw=4Kb!obN8_y^Rf`mB-eP8c2IQZ~xy_?&^ymZF8G-tg0Vq^*Hr_B?3%`GoowRdG7s_e~9rP>%xZyS2 z?w z8HGCE!J*eMda%fhg)^R22heuHyxR=58Or~QBT+_|JZ^9Pe)cjBid+tsm+>ZupHLD{ zJx#qRLqkJSV9rKC>?Cj!Et@3#cz@M+`2Zp6W|k^2Bz8rx^UukKoudGpp-_IlYq{Be zNru1!{l`CKs{{XFQLuR}b}M${onhzL|Ja8BnG$1rq<6t4d*Q1wz-Q}9qTiz0b$rvb zT1BUhv9D@sGwAxdNzQ_ZH&5HQIvXOI=f37(d$n^Q&f!Mux_I5i3htSDqHU&~R%_|* zAOKL4#5MOs!;F9UcN=02x#l(TYu-W;Xh{*44LKd(c=S-anT~Sf@(o;lfO7ykCq8UP zU8^-1$>J{~rrt=*9q={Jl*$AIRTB0iHV69!>j)T@)vChsu`yyjsXCS7JlXJeUvZBQ zqQ80r6~@({?Pq`iP)gg4wR8dFG(H#7)xfNC`g?i}2BEDY!yV*y zBrQ|t{nPWmBD0q%3L^9NvGw2P0tyYqb52To z!CaeluL&E#Q9Wyr1y9u_qxD0*6WJ~Ds?&w49UYK4d3HV(VkIKjS9#F^iH2}~_T{7v z8FVr67S&!yvWO?!SFJ&Na|QMHqds@XeRQDC`p^4ufjX-{$ukL8)5l8CeX5|!YJ+8* z{pUtBgZI;N?Zp+-V82_{go_1PLLMGEQQ4y+Q;PcQ=W<32aTn5-CU@5$Tu1;A^)4Xh z%Lhn)ud?*IsxVTuN~fMeAmCdJn4<|N_!Lc^gQWOfT(3TBN_u*oL%}94<*eJ=%k~2% z-CyAPyhD|))1ku+qgINJ!)0+)RpKa`yuMA@t*z%-Cn-689`HTV;F-&6+SXp?G+O)_(ahGJx_bPdgt zZ>_9`p|)kwZ!l=O+!Tr5iH2kG?h=ZDb~=)L$gq!#ASiQ5RPGUWCRbdm4vscD2u&BQ zVGfc~e;s1vr!RfO0PEDK7=cP4eJMA)iYuWY2}KZ(Wz5E2(Gm2~9O+uPNN+K(?dy}<+^v#S2Yt8F zifgxfH|FdIS}I)!!o7jO<$)sez&^-?Ha6|3?gV{|Un>PUk2ROV9Sb^nLo7Ish}#Ih zR=gJu9gf*((+m9=DGK1SVe|qG$(BF<9o&X;OGT_9kZ)KKB&}vmGF;z%3$Oxd9iIfl zrHt{0d;cA;-KALErv-w{R@b)y-{3vfzi!bGyO(U`?(WXLKp%?oc7jfV@QoE)zIip& zpzoWQcXLusi^dw#&iCt!dv(5t#u91sH~v?5Sb%M$=tSVAFqZd!Jnz_~Ii-2zYS zS>F8d21hWk_w;eD%HIPh(68e*NVP4S3kR1_)^7OO;fQ|$rB}5BJ1l66P-LC#7CXm( zF5kRiFBi&lB{0Qp&fY^1fHMk`qQarbZ|DU$5J)Y^kkLOU% zISDHr9l4aqkxGXy?o%nGL#Ys&QIcll-mtCOqdbx279}k;A|ts>ZksM5WSPh@wp?b` z%-qLj+w&dgdH#C#=kN7<{r21U^7+1R`+g;yvn6~<%JJtVhu(?|<#-x?cmAz>ohEN6 zNtPXlOn1b{B6byM8*_7FWR^Ww%!ba^y6q_#XhgC+aBvBA zSq!G)5;~>*G{%kYkGA(jG-4POUjxZ;I-arG7Z#3ra4@Gr&iMraME#YFG_?4V71d~` z{vgWRLBkoVrL>!kj~u29W_5u89vn*!|zY75la^3Ye+6Jn?1eQXR|ab zko*Y@3q}hPpL9J?Hju2-9g!9l;y^;Kwu$+hKQ8n+;Xuvw0i^w)V&c($a@IC((q-an zH4OGVLQ-|c)qvk?7wR**wu!=*ZpV9PyTj6IKclB4w+@R7(7XB5OV9Kb7l1eK#_;~a zmO#S4mGR2D$axUwu#RsJ5e%}UgYQdTopt@fV!&p114(t}43sa8d9Di zL7uJJ8-l&}; zeBSVTdDs>4+-+l}psHPgg}uxBSsbuA$>A<}>0t!{%@nJ?zwzsiP9K|3_72M>jvpng z3E2Xf_C-#33?*R{DOj=8?j?mS#wusMr&tbM+pqFnKY&afIdx(Q?=Pz~F^yPW9_m4W z<<*Z@jn*^$GJ>WQZL#YOwg<|O8vZo>Tf!5`B5+6A=h3qRRP^;UeXhm}v!$OdFE&s{ z_5oB6lTD=O0J~*TTP*bE@eL$_uQiIid7BMNgHt&gFH|>(k$ee>Xajve0-JlM0m^9c z;V;*(FvxVX(or?O6t-@TDx4O|RYsO=aEt|{Cw7CGy66Y)$RAzGhNDqFs!hLftQ!8y(Rp5}}#FvzrKim31?z z$FYuZ0D;`;tVfYmh=q6;swuA#dq_z5e%C5}VKxa>I*+N99hl@jmPtGB$#w$0yI-Nw zX#O%ad!EL?@2mfD?@Xcyf~Cg#d2N^scta}{wXl^wKaZ@KN|wa73+XhYKHss3*TPDz zIYE1_Kv(WN!S6bYV%GiY7RK;+y{eL{ZG#3wk%dH zqlfg1GiOr$p{&|gjzt{{RFNx_)*YPSDU2-^K4h*1xiHD{jWE}zJVuH`FgLLcAK$V5 z)MqjTK47%2lf=*WGLZmqoGH^Yys)PSe%mZ(AV6X3i~CM-OHXM>M7N1PPW_SUqm8W! zVR{`db;2psx&rl@9MX@jIAsz#?$lTrRxbPm_0dFYDofWA3bqSpXt0o7;s(@xynqjU z5yl~Wdx-Zr!Xb=aluq7=Ud*X{={EQ&>hUWz`k7P&g75g@^K2jMtAOVy1<@Wg z@gsrLXr!s{_e(#zx^(Xe#Fuupg-cLgRE*@WMyxtXWyttXZ&0txrqDLP$TeKG^cx7%_Jz*>{-Bg;D(xAR`82& z*=VgdZeA^LD#lIuYFTP}i|8Z8t=C#eNrVh1U7y%??mffp4%f7iq&gy{@r2HzG!t@F zhD#n|5BFOqcR}fke=gC_;&XHDN6TNC_&LEte*CBa8ewmh5b{b7H91Q{E1W~1qhZ%9 z_DNF-^{;FNr$q~vGV6lJE2K{_t}Dz_?ff6v<7wV6+*QP=TR{urBV|!P{{4t4 z{M=0U>`-VRLhDlC)Ua#WZ`t}6E>9PnfAj@vI+|Cr$;J@!m-X3}a=M}o$9Y9&?IRp05N;{o&ky-ARkk(g&Tt6Rff#vNsBw!QGAD^guF@~H{4 zJ$ffzjCh}X9~?o{pZ&lW%;KuUgVIf_=-BK=#M7xaV3eaqqwd#F*b6O_*Peg4x1!}? zk5!l@I4UODx+KZM_F|;!G(56gDjNFW*8U4Aw}KXHD`NEuJL`W^72PQ*kF)O4{8@EC zOhKu{TRrs)88RSj@^t)k&I{Yn8vdkf;iVL1V0%e@G?b}LvgS~z_N~GiPcg*@GF_{3 zOU4cRKBDs=Qd`S|AKZPPT*&8KoK5WPo%CJ7bW#oy4YhVJ3|m^3kyns)=qc=S6B$|E z=l!(C*X9Ht62&Rv{IR&_&f&oJw~OS=f!XoUu>b+POJMHfG@hbD$6_*W&LC{kC#laJ z+t35BQ^rQjI3-yT`F1SKVc=jlVzSY8{mkgkqLcM{L81F@F6OMFeN0remtZSL#nn7m zSei+ymEMejb`EU&hM67p1&nAdI<=~#xC&`+;y40j4=mXk7Mm82pL1kLEh2I0PoNq)(i3gt@b_FGQy-36^ zbElIPf<72(TtIy^!I6=DF=fv(SZ{@7P_yA}Y`UNma56coVgD%8JS2A2{2_jIz|0q~wzr*E zm{76rPtnzVKr7w3`fVvBMUxT&9Jpzvj1{71koQjM44m!c4MHXtR!6acWY271aiuD0 zjWer5@E!f%8z=1ZGb0!)3@pk4qbyu41Q~N26%ExZfHF}*H2AS~h2uXYu2w~Z*$YCl zuv{R1IMaiHe^4sts3$F*2_0$k^KxQj7+llfWfv{?t5)e0WV%7+H=xA$$peK>aS<5V zNBN64$s*U@Rr$@PPO1muckFIXiQ@+>pkr&+$X)@AIk(y00R0rHTyA5NUqwB&(@zfD zvxx7-XLA4q2E5NJPEr(S%x;x847?J+Dlx>)*$+e}cbB@i<>LecN9CmL#vUiDIyGJW z;U;-v@P1W2v3pj$(D+X<5U3gI5TRDe-0L~Zautv~5oqcsC$XFXGzR0TyeR29e;XWH zoEbqNtKF!4ks0CQOdY3Ql>7bi8?N0pxOaQUM7rI6t$Ta_UQjIO8`z>38v&vFB8RFL zXMmfToi!)f36}w_ycn1>WN--R1>m?qrrB>}xi41iWMKZ?0OxAXOz(sXW1bPeo!pth ztCA=z9|h1pb7qU={k8p)_j1Q9R1CiJ@t%Ur?A;s7O+z53^@p=`EkpE_Pi|EnFM9^i z6F;_DlLEvfpveFwAe0j5cLLP{&+0Bkny1_C;wBbkHUh0YudlE3UapB@t!o`s6C^TS zL`(WCDug%>=>1+1EAlwdQwuWP<_kDr>o;jwr13{@-U~oPcAQfILUB>jn-Zd? zQyjW<-uB@L#=#+>-N%@14VyYfS2NVv49O$z3dRu$PFBb1JKbPeQ6%DsnUR!u@aKSw z424`%dwgt@4ulE}I1r)Ub4y z5!ofxuzbK#S1e4|15-|gM4lxwXusB=1APy$;L@uY0QTd$H4|>0Ml{~RnY=J_in9lV z9X1KVL&gOYf_i0;60*|Q^*MoRAR5(fOeG%GAAXpwnw-S391J=T2AN(?x?V=)IK`3i zfDH#NqOXsFrAvc)$XVI(!zKfrQQ<@bf{JyAs>C%RFEPMZ7v*ulK71TKCHK24~9^M-Z%Q zcLQ$!n~?EG2M~M7;EyAD{j~pY4}uBuzfWhD6w1ttJax#-6feK%e9YCM>N%wC18MB&Dn;kI@Po!S#h%EsyEJHE#|z8|@i(`?xJBd_pz*!^ROf&TE$z|KGycHMuo zX&R0R{t@^saBg!mptLKVGn`U|81(=1pTt^^g9H=R)WpC&hU8S!BR;S~$G|alvM6Hn zkrAzaRK^s~uRK|wO%6Eo|5oU^ks)T=W(=)QMO>PK*NZnb5ikA~Az8X$hTux0@!El{ z1)D$8XTdc8`?#^;I1|UdF8IPJ=C_sT*{=a;Y!3_KJS-ffG|R^Jzb)HSgJ-!rlUQH* ztE&wqet8)fg8bi6;sOS?o`8cnIt@j5LrligP3!d4SR;xz^%y6h$9c3DpNQjpL$?0! zXLY{ty_g!PIM(otVPC@sNKTI@CKuKzpuHcZU;W!FvLKb74VWY#wx>!~Fg?-&qn?1B zzQ$RVGcTU#0#}!mtg5RUYiE_6nezp4k})-i2&j(^%JCQ>A&Kts=Z}1CypIR~)u2yX zoE_Fzl+p)R=ZDw!BV0wUiaipYU%oUS8Ste{#%4}cf{)76f=>h*OA7ctEp_t%yX*P& zYix|RWOE1+(9A$3qX8DBry9VCp8G4PD^e!2wL^AsAcwKhnVA{NnwrxG1zKtjA@dE) z!#;1yv$lJ#P}7DU!|07^+(N3>K`~-IoG3iSenb6f?3b5>O6=EHxEYmMo)AupIJbgz zfsc;TWSV(6I6{6}1cZ=<$LTC^n~f{s9)O75AIjfco+k~O_i|Vtsspy}yIaf<6!<}? z3}O9j+(IIA;L12bTpwclk_>pNvC;yg>bFN=lr{J&O@d+4O6~SNROPunr^A>HwEK)y z3Di*fDi%A+z{27o@?miGiuu9jZdG8;WzzOP+1(Z*HvVj{zf2L%4_tTC)0Ty)3WEn6 zBx291uj6z?>0K&T0$l!5gq6!*D&|Z388jzOpz86%RXZ#_mCO{zOs8Jq>V<2u)ATyq z$}~>Z_bEI!SKK>Cy5JT90k;6p?{@E~tHHk_`f=hU*PCS`_9OxKC9jq{RIo%pbSkVG z+SHE_{w785I~8PSTQtZ+_vnS3fS&tD>e&`GHAU0${y|sGkbB{Ae5OYlA)!RhY(0dz z+dXL72jgzu2lM;e7q-VU>ywr?#eNF-mzv$io)$c*y~UgA{OgMzbDD#$#(O>2fww_! zDxw+TsZ{xlgGq3fzCW&D3s>~l^)<+d@KSh@&CoOfL%$glA@%MuR8}OTPUvuo2u~PzI6w+&@@ec28k8dN(=HS%k=@)0@-x*Ov6c3QEq_G9^vA{Gii%; zU$-qEd8ls^0-ojtpS6S5f_)HJ&FdUVRKCA*7gOHh6%oDlzF`(#R!i~XW+ycYzF3Ir zPG?;C&}UU7Z1ty9)P`te3GrER>6v>4Qvd(=u-;H!Zh1P~4KP55 zGOq~dAqh#co1l=~_Xnu^_(FNiTQKM zAt;}rgHhzukeB_d*4rc{&ci2ig5;FR!p1`n_5*0u1p|YD7w8}~(jPR%$*1N3l{;$* z-aDZAs6D9YcjBy@&NzSZfp^Hdrs^tzE~;xx=#<_?^%`eO@68bH7*W`Qm1$ z%Ulk>GUfgEbr9#D&`$=pgUOI=j^(R2(ay&`NIjV4+D0xy)F94hIMEdSzm=Ye9yg%_8ELTD{>>L9C@#fq&i}i*qw9ZfeX+7s5w__YfsCeGi!M_4g;g5qpsJ-gFyb#bFy*7Ut*MYFAp5XX-(ha!wS? zVM|l>iQAD06{st(_AgOz--{&1p!cCxF8=#by7az(U5$HXcpOs)rRV?V5rB?X zQlZD$KPczvlBG~~-16uD3P>5&jfa(fjgQwAPZAi>malr;0HeemEf$w_D;tHyq4{o4 z*BLHgAg5+5&a@b@*5LPGt-J|Ox|d&qH=bw$`<(T$Y_-~gZS!N0`U*eJQuQpT& z#9S`3N5ibs3|m78_AMPmyWUp(U;m`gGdr8f7nJVaV{s(h>-YQ9_)RX&Vx>vKO~a#u zep`nF-FdP!ZQ>Xoub|So--KL7D#7lrS63I6pX z11>i{7=)>oJIokj9XE4|L;}Bf$Q`_;(}}|b^s3LBx2*i39$6fIpVa);Rg|B>2C?{; z!L6x6mu3z-2_4>kF^qw|4vQKPR;M6t)UN*QJq|Xz==N7?ZtON3URyi4FGxQkwZx;@ zyYxj|b-J3vYl96sw6k~Fu+|))umAqty`2O9dCWCjEJ*f(_#pk=U%iUSPTe~C^A;QH zMaW2#5;m8RmwDK*ay)MKu?^YJASzyl;cm$O9;Z}MNLyaYStzog;>|D@70rDT5S%>d zlZ*OUkbC7ZJu}3DdRjNo=L6@o#WU12Rj>hI;Md=|qYGBi;K0jQ^E=|T9$#lZUj%%< zF7q1H&Jdr+=ii>@G)HG%{B0m?5>D+cTkDP?$%W1H>U%|P$uA0^Su!nq&C;pHR5*K(B0`8!WJ!J*BOKYtp-ud+?+TxaBgV@urElI$6Do%D+IVdB55 zJqs_&vDW)7bIZ+Hn}yxNUCjC0eEms1IrkkO)T&2=&F@F~39PE0d!RO7r$9j$v zWlgEs`Io*H?w3wTNZmm0ES;nG8JaNhJg`HOTZ8pvS;bw!Ka)DF zdCsfVRxph@D%x^&I3nq$Jv0^H`3+%x9N_FQeZX+SIKF+>4IK=yeO?K47wF)5n&cSi zaGl@I<`Dwer;>288#buMX&|8@W@xwo;XSkdaQuIHK?ro2!9WAsAJJRbdcOyw;vjDO z5gR2IZQdpS(^DD)e%GqSNHk6ILFz>c5EQE_uQqaQOKq~EnKSHaX(ucSO2pPjTKn(O zkRD?a2`MBlEs2@_9P!xbZ4#mlRAXSlKLjoap}3Kld5t1Geq`;vu1qa_sqCzI**?WG z?6G>igWo>E$@z1?eGroy6jKR!18NGoqO)V2);5L^)&F&Yhxv%%A5E3Kq%TZNMg@q2 zjmCpx1L-6^=8$x;WJkyN2INyIHKXtOh|B5W-lX_RcL90t#T0H0AJod>#WNw9NcJD6 z%RCNG3JcwZe!LzL<#X%z*;)5Ne63Rm@!HpL@At7<@;O(v(7YVzQ0+8Gacec1L+vA} zlZHluHA0SLuiN5Fkgy&-VGt5=GAf6>+*bkwQ&F`68$T?egw7<$SO67 zQu)`y!tG3@gssLvki`Eor*Op#J&ifks8pm0gI`<$FDM{6h)1) z`K-+Yb9^qB6G1(shyaoOR-E|A%YKEc%zDeq95Ht@mq7TD!w&=`yCyL(MOIsd^*qHs z_Mr0`Ulve#l$q_)2Y7-})R}hhiyoTyuAVuPY{7@WBT(?V?`zHVx_`+J)`zWS2Yy$c z$}~GwJQB7HoT=f~@GV~nM|GudrTX3~dB87YG#o!2!;t1X*b7~M;fdYMP&hf0vY0*) z<#KOEKee)tFGK$_S%Kq;A3l62w9$Rrdu_$yuWYjy8=KQ58;o76K5GiXZ?EF}bdy`T zQ8xzO`N067iAl-Ph}@iPoZ5@>-dQ;~CiE?QN236 zFrJblH`&Y*VGEC1-0?B>aRCQUVwL!<@mn2jqYPsrCIiojKG3V{^c-DtBQXHD;nHH= zoEkpA@td!F0UU8SH8P+cg{f*3W*j3n@t0aP@9V{?uVi4{TejzN#pU+ZpF{Aa$Z-6_ zl67-N*26SK^M^Gkvuim+gN9@OU}c7vL)t%wE7c5gCZS|~haW?WiM8+$7E0UJ`U7Ig zk%Q$hN=_Srm2{>;63bd@#<+ym;vXkhktHcpvr%`MtkuGlb$WX1Y* zAE4GCmEo=x2U~^t5D~0DP;6p2yuL@vr+d+)eIS?q+gP=IEcdzZpHXoDy+GOQzoU2G zaTh$w=Y464NrEVm>jw81XmBY9dC~a47%t~QA4v1^(;ufYk{{trTL6j@q`6@aQ<|eqYzr?|GBbpEmFl|=j>)w@Xs*FmXYXC zAmkp^88X`PE5hT<{z0@}_G8a?^JaRq>JRF^>pcyWy^k4Uf#{uKNCUWOXdJKnGJ%EN9nidQ7WjEG5 zdrB=mDHm*cJXgH_NmAwt)@Jz4J)!SF!+VF1AS|4tp_vt~U8ysgZD-W6|p zB--MUR33cwux9&!VpDuq#_-rh~!_WQGezBI=rt!HIr1zLS* zxwt2%kTgQEUp2{n9Ylis>dD3onf3L4xvXoa4NGo-+ISL7<7K)>-1&WN4Wzz|R${HK zo&1&6B32t_dX$r9&zHhvA!WMds1(o@o^n~uPW_XO03=n^)YPP`cKJ{A=l7zGmfcM2 zzg}kyKqEClLF&E_2HUQ>R@Bni&%MFqh?b)-BVhqM+aD$auQf@lxx^0+4YMt8Ug*r9 z-kF)eTx*sEbdp(s+|`oV>p*|d47|TEe7z#s@sHm-IQhxnbsCS-L#n6UUt+TXK`spO zG)uy3j{dTS;+&cHLYUeJv40JHl?D0~uz0PqSkM$oryTv)Ih?QNTDx^7}n))If-;PaBYF=Xacw6~H zRqo6hYLOwW-sjEsHqeyo3l5w}m;UTK#xjB1XVDjK?K_gkr+$5BDnon!(@%aDd64a& zes>;KT=nVCM+hU%;eC$@=p_UHVuwe!|KJ`MLZPq!DPX&`Q$4ntjq{I|xMSjuaKn6T zl?e@m@cHmDI>~8M@Kw5(cndc`=`OhblRn*suj;zZv9L>X02%FmatkeL@m2y9vg4_B zm(==McvOSQ5RF&oJOucg(&?irj*Sh)-EwP9>_o+86Db zRxA8HAab-^sI9Bf9Lt9CT>diKCEMnJe5#^og7j0lb5lr2zljmVmN8WUQR2zM=+PQ) z;`2SQ6y+>AS)yW>axQjwX(=gniy+^CrnDp!ogT;a(zg+^f{qE{$$0h3=?5J98Eggg z#ygK+Ov`y}z)AD^uQ;d2!6_Bb)mjWIPV>`CO4Vi~&jEqOWaQ)H1cb2(wJ{BkUPe_K z0(wEnL>lMMMv)5$sCC@{r@^b&l%of-6+*`A6Y%&%kLID25C1M&2cB7ngpv0%ZBD}e zD>p(Tv3?2w6XglGcxZZbYtqlX4+ef8JpLcLZlNKxS(P{6^-Pz~cR?}V5nt-x# zQVYFsCQ*Xau@~q805>L+AAlX+V6^Yu1X$two|{@AAmbis7`1);_|fs=G}l%0 zvL`nQfJ96!3glb`hT}vg3AF;^wbk9SukTgHw&@f*T<%$%;=@>2SYl7%7q(Cw zazo*fYT%{AJcJ(r9M5^=v*ni(gBi6d3BMA*kDrS&7GV|j0HkSx=S;JI=lqQgwDbcn zEm~02U-&2D~8095>BRYmm?el0eILY0ihW%#>O(io^r)^OJs%f-@>P&81a-6T?i zMeSLCs_ss0Ew~h^L2~=x`m<$1EEV_YFX@3SUo!p8o9p#S3EkW)TPjWGdpc0q7FT}1 zdDZ)Y{`tY!hk_JWsfQEVo#7lr>A2Wp27jhlfq^ZD!r%^slM>I%tm!6uKnt9Iy*#@) zovL@uny8*j3au3XGaqoR&t#bd+?IvzYxPeHYij)AAs{_0FVFBA%Y`EJC*1_LYR)>^ zZpul~CQRE0EoO(A@mcyGdPT??ST*mS`s>o?UQO9WoOoCl7QPTzDUf3jdG4fXpJPh? zjIUJSnP<9XAze=%_{f$@hAmdscgAylRHO-yXsGdNr;9BBue${76K_&9oEQQdJ`@eJ-gVeGt7Tf~zXniL~mo1=27 z-Sq0SDmPlXb{4<)pZRc=F}29=?f$&!aKDt&0RDlk2<_l~wnO#?D7BS9<#u12E_K9h zH(cQ%xS%@Aiw|b%D=+5(NpzY2eD>CGll0HhdvrK+=|1|$;P%U1dPd(|4^w`T92+6ossMCH!y7>3Vy zk!R6Sw{A2p%pWj#lixO|OHUV+(YwY<=WnHK5Py>;q#3k%QkCtZB&#O|5{<~Ov10&0 zbt?#h1HTq;Dh4|?(j;pN%FG$wC@EB0A&L^Rwu?67;KkP3^_rU>te@y>S-pJq>c#JY ziFWmTI>p6OAq;Soj;HaO@iDCu%+f1M%@yGG;v zNYCd_4Ta?^;1F^*7OSGp$N-m$QbhK$5v_1Sa7>RsLUxqRBqn>O`yV;gl%!*vJ3u>i zKQJz%dO6pHz!H&}7uBBz0)X%a&O~bqHS_1JrBHsQf(*U_Oo#_(dnpcb&5CID1Kr7z z7KM1emcA;Hg zM`&I~ufsD^&!rH3XEuo`SgJm0H*1L9Vi_C03i0PeCp2{Xgro`g{i|-=n;!f1k6k6* z@9F~JLD#oNsUpB(N-ZibVOz}m=2J2`53QQeZx*2`*Vy5q9}C?|{PMV&83aSgGhO0t zewoP9M63E9L-hHdRh>7~UU_Wk|6P4j3<>Gu*f>2&+}BA0j**v8B92urt&Oet(HFWy z0~H!nMUulZS7Web0g3)o`%)rAfPJ4h-NbWL$?MDfeunz#!Z+g1#;=%iReRnlzu+#L zIi9|@J0;|)lDCneOe>`jX>zJevSDO2UJq=o$5iy<428%Idl(P=P-Bbg3cL@1M#{#v z?lf#|8AN-euGW(7mHnYd9WJC28Lr1un~i`_7J;dg5B`$}RU+AnLsRS=TIx3ur6Sut zf{QVN6;{i0M6CRlexv0PsuXg}gcOMpR_q+opmKnk5oImjrkYZU`LYeb2U&n-eqj^T zel#f~2peZRatl)~=3iDSnsb2c+lD290HuW-TsLU-S@b{EKAcQc&EbNUljdoIF4A4< zyU&|d05lP0Ylv$;bmmH{WOo9ewRAhz% zRTEITh1RYwC25gtKfh>TG1_dt50jE;G#+)azDnpp8l|Y(CJ!&0M@a|c_w~Lg~*VivC-n8PE_Az#6R)PnipC$Zwox&krtBbmP{qq6lF;S%|5V2&M zYAXlu7IN>YVSo!eWE5Q6`so+s+YV0zTMGF8N;wX&ir0n(=jCgt8FmVv5dhr>5V)eB zfGdx@-7-A<4w?z_0pn1 zv4hk6j?p-$@i9%mDkOwY*)wWoZ%;EC*oD>;FgjDBTjiB8-Ppi{aC#y$VKPz?RH$R> z!v+p+pSRIgp0b)3B`>tqJ1ptRP@nTcqdOR#U>ErutF}l@5bZrir2CL z0rmNlKQYxs5u2QNqL~9}2Rq$EW;jR9EMWV5+}jS1lMx^e?9H00Xt9P=4G$(YT1Yv<|S$!h#QYjMA zQh`95jbq+Xp_N{J&zRaoG$YxaQNjr}7#=w86D4 zqH1cFV$35lpQc>>T$TPOa=vbJlF-#ctJr+{^yyg#K3xK0JjamC#`$dS1RF0wm~~G5 zn8Y@4pyL5{x1Mz!FBQIw*nB9NwQ{1~Q`I%#d)MH{ezDCw zV%%A1CQCxvM~)get-AhlSG+|J8x1Jzp8J=ySZRK@;$N#cu+EFiL!Ee^U(@eQW(*-A zVpPe}v*J0MK0q`kEvkru#3}=4=ZGPj&-s@-_K^ryDfgMih~W8GB#^xaCdcA@@0t{m z+Gqpt@S|E(Qg}NXFX+f7zXf8EIWoN4nlbBX z%O$1J#B;`$#R!~+(f5x^P?hueXuU_0dA(fxYzyEd>?GSO+cN1#k3@{zS7mDkVHe6v z0Jpy-dh5F63TbP{QTCHnW)W-+df4gk&!zaS7KF zQDX6?E`PVB%ULX9&I3wR|NXlVCNVK7My$5n)CbZ>NZ&7sIA@x#L>Dq)5a%+LlMEmy zOrA;CJLZiej6P55^8vP~Xy&z}|1R=LMuV}5K!6n`wE{CZG#Tzur_m4{#C?yu{GqO; zaKA3DBF^bLc~MPl9kp5yB%AJ1O_Aj)0XdD>p~YuxP_ltRh}aynD2djiHD<0NXsP!Iqs zIm40c21^?_l>6+{=E^)Z7w?K@PNOO3-=|d7Ki+IuA-=7{`ag>znNwgB4Gmj#JKGqWk z{HIcYfPzfOYvxaf1@z4~veS%rv}K9yCIu_FCfH1m`qD1olNhin;OnY3z0kFQ#<TA*XUY*Mo^M#J`eknpGBw>JAGvFWR;p($WYf+nwqOB_;NTm{c5U-t9LmXVl ze?xe?xD|Gvl8N!}w_qhlLcK?FmgOK(amt2^f@z&c(l;Fp$$gTbWu=>)fO}Kum`!5b zK$r(2D|#6Mv^JMOh3nlteka5Wt>>Sp2OWta!UA$$EUgdF`p=#)^`MRU6*pp|E!NI@tEGX}97UDEuKdqU2w0Dl~q)K$1OF=5>uXz#f z{%gnypu!NN^WFm$Z1+D1&Tq}h4Whs)a*}`*6j!sGxq;po7%Xu|8SWY4$*zr_eBj#0 zi1CS?QjrhpyS#LPS_I67+Cb;`a7;>Y{QuGtGz(d0!}&|nQ?;Tg&J{UB`C>k)xF4k) z++D8^#j1Akad>sVMn1WI4vGGIfC>0qv<1IcNA8q4~|S z!!Ho^0)TIYTMWjjeYX7LlacZ(K-&jER~pIW_D7qt`86DwCgrnI#L20*Ru5s&=u;ia zWX)Oikd{d%fxemSlR#8JQa$m*o^_;q-RZC;IPXvvh(qGDj21-EJs*`g9mDZ{yeDs= zzFNya9OXzn;{v<0{|a{2bCz;$MlH)5BVy7 zOFtZ`w#4Gd7zSKL!54vj;@w`#Kp`GF;VdLdtMrLnuIdGUdL~a?Z3(H&y`BW@7W@3F zf`57Z`!Aa7ko)vxBsQ(7RJyBWW+eG`2&JM?6f5um6~(TBPbOrY z*?Ak~12Y6oZ%N{8`_>8hEmpq+ z^LtaY!O(XgDbOCzE2Vjj%`RTB4+HqZ{d8;o**H4#>Pksy?T}@&7r?yqZUF1B04qrX z2+V+Mx@t}nY@qL6Ds>v)56oYbZr*Q+PYQh(HJB#zu)^lWWYhK2=~h(D#zW38e%Lo5 zfPoM2d|uKg8>rGAgH_{h!d`Qjc3=D+Z>6MZ@vDgt2&JT4C+3#q^caTY9>8~uNsMTN zCkA}uuM$SzNqArvl55tANcT#1t9T{LZznE1infrdWy}9-7gFmE61KFrFW_o;-?Nfb zy?N15{l?5fBd9r(CH5hT@9^W+dg~`5umW#k&a}|f#I%f!b-sl6mK&a8E{+FBBVqV@ z_Uk}?^;oAl1wUuVXT+7(l#_8TW%4lYGJK2{e`;Un)kk=G4}ybTv~qmioV0*A@hLxw zNE;@*GpY~pr~VC(VV5;q!yBz!-Ya@oJ62 z&)yrAzG7I5P)Dj7+n@BvQe?gX9%i=#1?Ha+U+XW-!ZoCO33h{L0K z`RvCe(<{>>@KvU=TA^gj7x!T&n3TeB9UG>b!~RY_C%4y(w!8{((L7*5-;TYSYty08q_9&n`rZxee6Q2k()gZ}b}-~IV^`G>gB6DvlI zm}usYjGRZzl)iLb0g?XG+CYAVUC3u8ePYA_C_wPjlwVtW$-HLrf}&#&DHHYX-AU`D z#V_(dfo{(qxl06bdQ7>btgG0-p0S{lJCp?wq`l>&YUM_Vj@MyS%HIaAQU5yy_#$G1 zC$ghUtfa)bMvR!*jR#bh>>TUdyeyJ(qbHnoAjY=&N${+l+Z z9BN$OXIB`yqh_{F;l3nUyE#@=Dlc|z>K;6bjEVl0MHez(y#3aNTL$uLR(?>*7{UE0#W1JVW=5LPQ-@Uco5e-n5Qcx&T6U_X?#E+#^!KQ}4Rv%8A zYw|Rt>A7*gYtZF`uK?-DwebG8b)ho!p6^X^a1JK19Ye-z8S&FgqVU5+&o536-ZOQW z5v^M|hG1{_)B^0+HSfuHOa4=Sun(R^g<&Doisv7eW+ySi_HnBissCiPR(4YzMo-MR zlJrXRWnYLLHVXlv7={@ut#n>RWnSFteBX9!Fa%^t601zLbQ|?ppSdl2sil=qL(9f5 zK#NL7_UxO8r7p}I#sD%@CK^w@$_n}u8=6l&@hfPgp|dcDfY{^p(}YS@`8Ux$thUO6 zn_5C~L|P7l?}}JsZK-76))_{-0bfc{?f4UQFn4EBu{BJVGqra?9{s7;;T|!FGU`tI zrdD=sG;>q~)1MF&p=a;nA``AlJV>|<{70I3J+2C3!_cw4Z29`>V*I2NWlT7h8>x^L z>D{dmPb3gT-w56PMljDgr?=qU77(tT%EL7G5r9tbLCd52%iW3A_vh_lIEgaj@Ch1A zCH@0vA@Bpt>CjSDjpB;1C4uwFJs_TRz7Cq-krIVPuL{XV7D{_Qrsfe4YTM6aAuG2A zfadYf@Hh;p!tt%k{YA=*$4lnN3rts{6LIXfHNe)b7L_nBjc51bs2+HVu`WayY}u<* zo%!z$D6y$bz5G5&(h=DHghG6g?e?1n@F0+!o&m9aG4Tae+|L#B8_$K_N#jFzuga?p@bTj9 zipImB!pqL;mKZTX#u~B0!L5zmtSG`NbIU}^{(dSRduXGG5&OMZQ>@u|)b1~8#UGiA zeryS!VB&&ppm}1Kj5(702x5lw^ymdi(X;aMumxtL9aay;*JL3i`AV>=HqRxP=P-vZ zqe@CH+4|vYn0@3h{Ra`O$#~%F9q4g?RU>0wr|9l6hovS=tZn^`4%1(%+SQRaCI+`?rpD{uF46@;eZ^2rbqA2IsnI>A<~HvBI)q$t!Lwi zj-XVu7AMbZy%AwyVZnA9vSBKuRx}zI%WW$i_>+3v1gNwM$Q~`3=&G9lXV;^}wP*2g zSX1P77qo}pt~_++dq*`gkdqk4%<-;wtEhO45wej-kW*z&{9J%C5q7(aG}7%kNf)(z z;N$v1Kvr6~nRSamCOk9k=*cr3^OY#VV6l%CckgJCUOp|f?Qn?2{8M(=eY^LO(JtS{ zh9yR6VC(8vx6(l5cX+hF<{Ae~&d;De_3vA(NH`_O4sK!P~eqtJH0^`x8-%W7eR!!Hz{G+NhD5i z;=#AccMZl4Z1r#P5bE)X5)s^FbRS z)gnTw$=!an3hKdDelaZDAX`?XB-^VO{=6>RwOq1%4HtWvOKwYga>wJ3BTVeACTVq7 zPf4C$Y`Vs&`)h^ne28_z^lqPA;SlD1=u?8c_tDvjS5ZV{LY6xaT1MkdHx^7JQIBAL zSc6ipXHW4W4eaId9QM@{*i#RUV2_2HoE;?$5zyQAEU^ZQ6 zId;{STWNFGr`xhXv~3%@%?iI48%Xz#m82xYDL_Jd?{=Rg&NtRBTwtSul<@VrvDGRq z9!UO1MjVNcPSx9!yRbI(mCfDH-ULI+YP-H$9~TBuR%#1I-4=w|>%pzd3G?QR(P(nV z&AsRBX(VSqsu%ot;2!N*Aw@|%&*DM52ko5Vm~K^)|C7wpSK2WOl>K!OX>Ie{+qlAB z!3?(G5S2)U)`dNWL!z+cVWvvWi$@73=&bt~n<|JTlyUk3jk^#N+jBKZ_lyJ(x+Fb;zhE{sC>pGf~2w^?PqBu$u z#2L3+l^3fbgnbHPzLV;A!cnx#KE912 z@gQtnF6K+vCU-B<<>He*56^}Lzab0{356Q>#SEhotGWle*Sy1ej8cBF+j(hIJsKsmvBBDq+vf31Ef&|}44oM*ey~;C6w73Qs&D5e9N7NpC4;ipWAQ(rK zzUCPQlV_v@<Lx&atMbl5mLk=4Q&YL92wJLQn9-ULXgEJS(5yR zu%p-rkI9J1@!k7=fwL-q8w)7I;#CB9Dce)SAFIMXEeYKX zUBQX1M8v%?7CCOdzvUcjxjg2>#UeCDCjOxZX;^I&3jG&lNa6th_b6924i^fom!`Lh zG^^Iqua_E0vGvRZW@<;176aQ#=N;}#I28WON;d3kqGGixBRKlV29%cua^W8C<%~$#NYER{b&=-`76 z7VCT)cteQe{w3c~q=5rv+E^8-kd$PGtl&jTseg$WK6|91!ObtNV?}nHlrW5S3ci*N z?31g+YUe@5;c>LP(9vlElC!KyUWWmin8wqruWNS#d(y4GQJ&7~^cyF47 z$*tpvx34Dz7*ShU*1k1Hb#zwCldP$=e7dT#jif`~|TSZhQRgEk~$t z%>2`ymjvGE2BMUAWzSnEKwOkD)oC-2d$3zRr4e1SpxKj~h-5`rf7;;{(qio9qzDNWf$$D+yHQG6bNY$3A{w_bd@Of9K?D^h* zOjxTv!j}$j^allGKRP#BAd9<&8F6j+}M`<4D%C! zZs$}YJXEFsG1Dbd2^=ZDzak1_#rcy%4y!1TQyX)UcFue;P$;JBf`o}|WGl4rGhYr? z6|f8e&%)yiy8&#rMeB!*b6INglb(-2Y5(6M$VEe0|Ro-8Z9|7h|B zFmGr(_Tvj5{d`TIY<<3cBiA=*9Xj#8D%EDiBW&I%T&-1=?a-zSjX;S0oGwQ=MZ9wq z&odl%GOY{VU+EQ$Q1n}Dj-xaD@OaCm+onf}?oyHOAC{rQB2H3D{1GTjqbGM|JBHPk zoL&XNHP{nrY7zX@77r;60b!4XTwkZ{~CS3&T_P5GQg zcXfxF$(xA3Ul0^OFwFTB-Q9~4)z$YX1Y_QT20$<)QO%u2SQ%y8TiCyD@R2&>ENJVF z#+*dPmW>0bp#cGZD^AT1vi&?rf9IL=?t9ookA?9MR0+$acyg9tIU&>L>M;K^E z#W5656eAcGJUV`G9z1L0xqR0E(hk1<4!#_CR{FR&YwD>s;IPXCVQZJ-9=29p=^K0e z{qCGcom^S`DhhE)0g^{5_Sobju8xo2){@^l2_^>7C9N?HJ4ny~+foUz-o4j8?|C!%aSPL4 zcRmXf-GYn<1qI=(_^4P1rPobPG7U88S9YJD10vw@^u4QVJx-NOuFX7U{*3%o1TezI zI-1bo*n3|m^BGj0V$q=}M|Li|SSZqH(W+;3F5YHT4w=+qe?M`8I4oY{F~zPeDhZE-B>lO`w#u zx_Mf3kg8gO#-1E=dZrXFj@sD8&PmOKgF}kHORFb?3wAezox{&GOO=u49U63<%xYrc zHosiyF1y-B(LaePLO6Zq6N8jsf5AuA=Cq7)+;MxDUF`U7M_030ahrqBjW$l3pRL91 zEp|DN3*r!$1o_goZ03fiwywXrZ@060V%Z3>8#}$e#t&4?dqq`+c1l)}^R~gQcj0nc zg5Pdmz-|fRQK=yN6KD@5;C&M%HEV6B6N!E z(QzxX_bjq!c2*&Bh>T?K?I2|Dm3?d{j`4dP_x<@ke*bvj{eJE1by}MuBWR!|~ zgg17*qe=f@_m1)O``F3&KUD`TEcPdUL9q`Xz+!g)I|spznP8C%GLt_4j@iN3zNPK& z0rsx|P>!`Jbc=OVkS%YA4QS3(@Grth zX}-_puG5TlWnH~dOTbhIV!}g$K*b+cpcro!Ns(`I7@(>q3ym}NG&BRH1^@)KJLIWC z*WI{EwM0PJ<~~Ba5T(D}MP@50`Z0+XQa>v1#fSP&PX~g;{e*+=UuQj) zu?1;mihp~Q)%HS^gP7T_8T@mssuqMWS&QPm`I}JLY4@_XCB?nTk`5*BvF3=xMYO0B zFrTy6L3zt=^vhbED0JlhbH{HJIFQvc9_0$;lxnH)Han;wcei)bF>V14cx^lwq9j2% z9)hNpR;ydx6if8U#UTrF_{?J65^FcT>WY~Eoc!K(fX+Fmu2@T34}e!r zRn^WzDbZc(2PvVpDA%rEf_`TnR$E~_lMM#^Kc$#0-#VEbbq*Mob?Ivpzki5Om1ktm z)%v=@f5DMks-<>$zx*+>NP2~JzpQX0&PYkhha!$tfttxj9!<{11oVzn&|J~Y0HkWf ztR(n8;}sn5+qx;w&zwt^GC_8Mch$!O(Wk5SKS+ume10|_6iXMl$baz%oUdA=K^M|58?h6DSvT)+BV$5t zA%o(YDcFTLxL0BF4y(bGtg_sk+r}Hlpqfjw9}{S60XICo69e?7bI$l~`frGmV9dHG zC<3z?`?(qUCfa|Mj*jlxJ{bN6c6je&U3NS#U6V$?(iZD6`+MuRm(%>@K{q(9({nE1 zIM?O%@j;!4*7HLq=mZs`dx3IJznSLr1$tiw*oxMM6vjf-%4mG@o{E>Q z)-HxM=r;t=&u?m|0adCQCHnVg+;48`uL2Pb3=Q$Tx064Vs!5id?hFX@Lx$7RU4Id= zpM&x(2Pbzm)uKLwmD@d(dH|~zaMWffLG*gd3a#;`cU^au1{`=4i@j8a&Fwp1=m>`& zAOJFRTehL?iFTKL^|O#zI-sk?ek_j-Ju_0e2*h+F8?vzQd3K?yqVFw4y?}qEp2vcl z`}*rfqF+OZjQ7I3S6@cDptX;=XnB}-KmzLp4Y+mzUdR3!A3;1y)Rtniuto*7rJ93D$A3=fNmEWejs($gKGZqCR{jig>r7 z2J+@bJDXrRQFpJCA2FWEG>%o)-+r)BV&wPR={?AQR3|wKT1ML1`=v#m3d zq0H9*=pG`gvX+=*(uciqa^H4sX(V&eS2!zn%VkW5 z{xrVuAY|sgTFa+b+)kb$-WyO4*LpHqBf2|x#KB^uPeJ(X4mP?puoL^1|K7K!SLF~^ z#a{7F_$$mpF;R@e2VcUTgastKXJz z_tTU5XA$Z=iSG7>xx4YK$pWCVND1+iDcBK(|5;Eho)dppVz^G%p6BDz@7x zVxppU>tI73hju+bnj;{_h$EG%L08N(nE=%XBC&NB~m?zN;D6(U@^unFmg& z+VI600j=|Y#PJbvs$Z4wq`$TTj-+hzRpB@Nuu?gjA+~2}?5s%u+@l6FJvun0#gsg; zxKEDnIgin}eLPn>h7{Z>*jUGUE84Pnm@V#w&-*w~n zms6q9I14>k$#NQnkS@5eXXySu$|n<(uUAbGxIwQ4c)5{hBHQsYbPSZBZ``#_JQokiK-klPNz0@Hcr}I=6u9rarMoRrxOsp;%alu|; zzc~e5sA5oPTj!!Qrp%txN&;ll9{ceRq)?a1n`F1qFcR)}zNY5!!SF2A$ISwu;FdhD zf(qY%D-6LCu9fupBf!em^s{i|;B$SOa6aNT8wt*zc23stifd|tu!4$Ar>jCR8w-rG z-Y|Wc>cXk+D+#aV=D&$fa*=1 z$XRf{EWezlS{KpQeiM^TpyG#K)NA`;4Nx2(wu4BlpB~Z4$7Fdn?P`vUGkLCUeIZWM z=7}~(lTQalz8Z==;tCf#^a_f-ahG%+3$c6{44uP!(#2{{({H8UKK~hkDcHDdvGyl! zC{&uNALnOD=CGVpUPiRp&-2*qp|If9>xrHbe|BB-#cr82z)LA}+;a&Rw`1mnW#53> z9zV{kA9j6Z@6%T;HV6I+gMicw0T%bK8zOUfN>;cqU!iHe7!3aWm9n4MY>LIO#oJk# z0jo{?>#Ns)w=VM#SrJo8%d6&?Z>0~T>$X_-JKJ{VcK!is?K>$ zDDY-IEvR!94=*aO6JV~-L5vk{)UJfP++F>NkfTBs%>8YT23ebt3T@9>`=usS@S+iZ z!q8Etm$p8I8!yMH7mb(frr2C;2x6h_bcHI8+NJ2og~n`T$$ zM`z(M=VXdtWknGd>qmUQoT*@APDhCoAiR8}b#XgD(%sRUO9+W2<*X4+6o6uuMUl|w zx<=fNTy%~et}EE6UXbo)k37<&>NxcWz?KuQj7WkO!`$o>jG=e5fM8Ha;ZyTZolcdP zBm}fn0Bjig7T~vHZ+zYO2|IG7S+wb3kU{C|)1eAX0dN&tqh^@86mAO7#_qpHn0n&h&vBlrB-%>Yi3BfLdP2N5&fj--=d%n z4E;wrLR{IKJ2s>?y7H-88m|=fmm@%+3_k{oP5O*5CGG%v+h(YTt5sB(KL!ajDl+EQ z#8&q^mo84IS?{S}$|aAlD=}ldFRE4#zYvG)h<*M(*|Qk6+YqE8#eBCW!Wc% z`4XbzQ_sH_6mToxr95FjC{ZKlVlh2b_6C{{2MyFyz=vF3VfJWT!rsQl;D&)OWux!F zsW@8@$@2@()s|sv+mR-ysQ&0mQx9FIb%FMU)x++U)8L7!349(1* zhlPk=B(s#k_d;_=i-4Eg%cTaEE0dv$w9EcAu4@6NcstJ!S;9$9m zMXa2eA9hzPQ>osm28ekRj^a^^Ngo7(tmxT@;2; zg}JP`DUC6*)fyVz{QgTI?kE)-HO7STvOlaVBW$i7QwkYDvs+c|56(m&AJ|r9HHHMH z&{8+BJl^R4dbkynL7~fT(;-!ehU(I$YX137k#-@lY!owmKUn{tW%JH9*DBz8c(1p> zSQ|>Lfqxr%V)A#(GKXQPKJRXj;1}wjELK&zRq$yGrs>iyy(v4Pf;N4|Yo5H*mQz=W zZ~jF=u{gRNz?ymrp-w_<#4pTNV>P?&@8^^>Z^s#x2OlC%aiN}61&n>R?)@oliT^c&b?l*l`ansJnGw!eo=G6uo=LsKG0DG#Y$nd ztqZEM79*OvH3IJmPFqC}P4^d~P)S7?6VWA2%ZrjXys>%;j1w(#yn)zV*uS}HOa zTXFNA$~4WoS0mg*=VB#z`@x}S50y-g>_BF4>_e=Mjf)$R_tce7R`ML? z;kd9@LtN0^a(;u{JBKOocb3w_+~pmH`VFh!0d(AdWr>)%e{!}o$UPbP`SfVzyIm4O z?hRZ#XGlQEP+6zK7w|dK{@^x`ZdZm1ast|W3ipI(BZCg(0g~=|jAZ1IwL*A@VW4^F zqy0n*$^$8y-B(HVXWt=|Yr;G{XgcJOLfq%SQl_9F1FGwhsy zaS(Q-D2$N@-kE7_4?faBhTyXj3h8Z3d^6Y!t+UaUbr@%^jN=WnN&FxZ!Cl@xIGdGO z%0zS*J3Z?2rjnJ|g+2WKXdE}*<)sNg9S81c;Kh7Tx_j}hHafM0fSY_n)dLd{u|!CF z4PbyS-~b94JNxi0E3{h5W6+uTfEblet~d&93rESknU)A{B4PeZ_9Wq+kNDi-_7(HL zF)L>#drcu2VpXy$o&)k%4!b!))ybe|*DWbhO&#RT-*PLMp(26u*g!?=)8Zbq^GBm0 z3d=L)j*f8@I|*p7AxR`Z*%VO;J$U-##)PsGo7it}B_%BzTU+`aOl&himnm{YV!`4* zcbKhkKy9r{z6jz*r~)1odJ^173qY5-_6qzvmardO;(|kB;azT583t(PKypOq$BAbk zSddEtlbxNy$7U6c0aK9{CfhR?X%Z590l@Yup~Td22S9&#LbKK$E4L&1^x|e*R@y{r zb6|YJu+p*>sNsVI+2pFgGGAEOe_Eef0^tRAdu%2U^4aqd(Ou7+8kVx1`C1j`dp(*9kebEuRawmLaA>(;7&=&oW23UpL3k(n#|DG3wcfH|$6*H}>fWzJk{ynFq`n z3#`B!Odpae`wj689vmsg_30hWPIAkgK=}~$ZdLh~&ma@0LKW@*8mrN-t7) z8DjyCG`IijM!^*YAKs`-LY$^FCQ)8vy;@f#B5~BIkTonX8!I+J===&JM zE|Y}#-|K37n!@IEM&#e)CwVS>RNCW_nVy$w$Nj|schl?Ah;nhio&CbjCn^G@N_yR3 ztY}fxH!=`H=pO?W8V}k)Dvw!fXb_KiQ3#Fa^4;B&3OWo%pjJyh-@We;t-AJZ zM~@h5M=JHST@K8820YS**?CMT`%?v*CK-Ee_~d)Jxws0J-Lp_43|}Tu7vfPthO!V{ zV^M$lE-Y969nLL679zDL4=7^qeo!J&>!-b3y)(eDGrc{L@w;4hW)35BgmlR;92prg zhOK5|W}LYaKN-Crx~1aF74nJX9c5^2UC}Fe$!A`irj3NoCyFT4>spKyWK_8P$iVpb zj5s`rqUROTRzt2xq3k=Ue12-ZX!hfsT>6lgHMCGyG+HlD(ZB!(OOP_68+7gQC0n_! z=YDCc`G!}Thw6p?i|Lt0n$$bT@XpSeMmn-39Jt#PiP#XK0S~ngYfs5kmRq}JIFy$n z)XoN4tIw2`&h)NlW|Zi)x?P)6UA`O-MKSe#^{=~~@jI|@>j7hYtv@^cglsnN>FV^k zFvN|ho9YWIlZ7L9rfKHuOn1oCe(n8ozP}86m__$adNjO}x^YT#zir3o2}((l~T{F6{8|Q zGrw&)p%NN*zg!@pk?GaYdR>y8cbLN#H~wUBM)(lF5}9;5)K}n(a-+^MX=#PolbpK7 zLZWgC4IIf$i@J(?UzHzMa@-|_(|gi!7WQY!`&SQfw5hcz!PQ^yzuu^6XlOv#@+j37 zAi{IvT2XuSrT0LN;bdgGs~{tn9gc(Q-qcAH5u8BKkxR9wgik%DM@*q2?ODH+Fn8j1 z5QUvee+>=!XM=u!@iC!~MwL_wkugK&;^o@Oc0vDeeoJ@lC+7ZNf6rJ#JTKBb15SE+ z!P54qPX46c6E?OccW$wr&@irqjw;Kb$nNVhxNXVq3&~9wtiH&WGw2^-zVxHCUNHr>l!@z2=My_C&tKkQZd-=lC?7gHPT@!k zFUU?TFGkcV@ZMkt{tog4H)cwgU*&T> zwHmb)7W-j{5=Am9o{}WHpcGp$Rn#mmSbttXS8Ct>9G%Inh#O6T6OX;yu^szt)G+=L zNu4MJOVAVpn{`V3QX1gn8LkCfY~}G0MpEc?7S$1?);8wY-fgq8gbQ$IxJGRdFe~Bf z<;G!*Y;G%5kh@=+xSeksPrgsFrHcwq?DsMr(-r_j2CY%h^!2iM-|J^-y9wN&FSUl< z)oUr@``+CkW;B)B)SNS{q_UV)_;&lYyZ`&tzBF0yV?A)Vnw&u2uQHdHvFwO^2^wVk zrWmj~e~jkcR;UOZGBB-jSXjcoCY>@$(8Scs^p~Jl5rV>VAP#86siJPWg}T6ptSToZ z>EWE+Y$}CBLmapQ&LLav?^IA1j#4`CO4)$E>GQ{fk30lLJA8e82dp+q_9dioOb)l& zc4;IHN{csZCT#ml5F0n($GVUb7xY*yW)fa$zI@piTX3`Ayfah#)umn+6VlW~it!&C0t zzk|dt(aGdh5Dt=s-&+kya%0Y8*DM%m3EOIWsrj)pbS)XPR-p_%76auA4rJ0MeyXQY zWS>LEg;B1ZNn*^CH&nN2L+Q0+wL_zCG$r!UcWW6I^Tc>NR*W|+QM+F{dQMyHL%tIa zl&AWB#*U}0hT}-*K^lFTI z(N^$Aemjtwlq6T4qEdiBaPl{v?e_|fadX1O()uKklubTgd2x+kBM?rTYx-eSqLPCN z@uHhGev$#tVX&jgn&PY{C?64}jr(p2S~+4fNUdD045%HXQ%9Bd^oaHAOMC|!*KJU| zi9yzVj`Q9ZRP!3IvujAjq8{o(P0z(+X=WTb>W+3rAiP)u zM5oVPWjI&%!n@fU45f%n!AwJs^FHz;#db(e{zB25?xfOcYn%nhEx0bHHGhe^@Q0ACs)?w6o;l~C_a$3j z*V5G4Lha!1YC)z_Cz9yR|EviGi0VB~?$+lJdYiyHNAH=h^xB3Onb4-=7Y#|95XYgX zU_FtEA?{ter4U+ty(wyei(VHyp!IB>Cr_K`-+yeVGDsOZsGYw_IiB?EXB<0(8t~*z zKkwv)S3dKcRv;L3Rl*VY^5&)mceCzJ_sKsZblUf}vz^T;gNEL2{ccA#JY&3EOd-p9 z?EEc=LiVBCl3sx`a}rr^-sbn>&FU{YF8p!n=1|Tu#bm(|b5JxOYoKQV<>&a6ypiQz zsOf9CKOx9y$C)OXuT-P*6$rrB{kY~(C(aY&@5ol~<;JV|yw7q$CSL<$1cz%r_jOGw zKHY&=s@1#_eyv)wvDtBN8>$d$)7jM2q*s1t&hd*efuJbFBWTPV1{2`1Q*eRCCl%LB zmr^LWu-850ur^M#n8Ih0f>%DQHVIWyddMAUfW2@*6xpiXx*d*^pDQA|-@b3LAgF4r zc$~nck{8`1!nu5{j%0U8!@5%u_2DU+YnSJwD^Zc z8pxnx_DVn?GP5K%^Ap_!B_ZSG4ACjIjdH&JNG{#U_QSU~;{M8hoH+dgfKyoVnLsxLa}k7YVtjpfZfHp6h{-S=jU^(Up? zu90LSTX^BeqeJ``8hHj|p4f^fZT?+);>RyCU8zSuS$#nutP{nC=H@O%-2FSxP7acJ z?E2sb?@<>uDmkS-Hm{W>iqMIhRF*TQEC_;q3`WH!jliXB=KL0~KDcGxq2V!S{Bs82 zCIAZ05lMSIz_KX|YyOS&qshW(e2IdLi*HTkxfUUAuQU!z*7}R|!@3?`=oB;cUSv;h z!BH3RXNOBtkmt&6e!98}$45snl%JQI3^~r<2NV1p989-a2{a|U_Ls7<#O-H^UQRvx z?%d+r*838&MaK{$n5ekJ@uB<;TslDv9Hzn{7plSHPYQ$HWG$`ml%yQG^b2W|Fl4${ zK@|D2-&K%kZ-9%q@n>x#Y17EwDXop6x-oJ~wEcqLddg?!AGE6e3+cxXkV#8@TLOaB zF3)EDWWFy!=1<4biGn(A-w_-E?+0xS+%I_p@GZ}`A%5`;Q`@Kpozl701NWp7TnC(h z*Nc|})>-SQL8-Hu;B;5)oOrK&VNA_wBjJ!$gu%2)@YfMT9f(hkT5dg~8Qu4Cfyk>w zY1pc&ihr{diy3$O`hq)x8mEf4KH4>Bk_oNIDR%FZ5T>`bAR_;eef06Tf$4X%=B1f) z?FC*x$(KnBU$3EeP=))Vo6$A2PXiL@Ts2E*pesDCMFx|FB^E(vyi&q*bzxk0zSE#Gl&nvd6|lFo4?66|Kq&uxs0w1pV>3s);k zTc&4Av!1O>he%y>d^3)E_pE@W;4&ue?ZJ?gFa|fE{J;%b-6+f^BJPmDT)DD(<~CdT zT&-V9RUb%F>X`Y2WPgCARd=H@X;hS*Q@r)Oh8 zEUjRc+mI4jS^bsPR%b(7M_kt*3W#K;~i^#p@)e*=o)s>T+>%p5J5;&Gs zr}2}u|6m9@FY!|6qy*(o{kErHJ`l#dPOCgp$8KCnWz$2be0uQ;5G> zYfqm3N-HOg*^GC*Sc}d7=cM6%q_se?HcWH1KSNqNSLpel!Q+2wHGC>p|7?1{6=}I) zcJQCX<;X5@p(Nw7lLg%686oFh?nJq@{1;n_eH!?y&%-CLH^TdD17l;((uHD-k{QUh z&DUL>zRsLKwwz%KI8xaEK)+sl5Xl@j7{XAjIMk4%cR!x$0e2zcx04M><>x?#QxC=^ z26*MIpAlLeTAu}(j{PA0pNiABH)=9_yT5!E*S15MKh3CK9Cl=f6g5A}rH6Kn+C76K znbV~y7~T`w?B=ts8#!G(_?PRF#}jSls@cT|@d$nA6|xb6MlYjT@1>_dw0>?!TroNJxXMmkWNmN9n2^GzoTaUOgZInR9cMwSCw5B^4s7rSASfK>MNe9<0 zbI(C$xVF;J+zKk~Nl#0t7^kb#2d;p*e3^ZV^|;NysoY;HhymqghlDMPyWBj!XJ>IL zIHUv{tZoZc3omN?{NGcY-Qm!+Z4;~(!pWxdDCxJem+uwJ!2{-k#Aeo&rliQN%Ms|Q z46Fzsf5=-c)E2mWvadA4<$flY(L#jR!~dSeudH7@0XtTab>TNUcp6h~GUf^_4lHAD zwd${7*#rg_(AAzfjT(p`{+ojN%8GS{`ju} zj)Oy&S;GtLD)F1>7K%*&uf@1L%O(bJekF`xxp+{ypUHnhR`Hvc1d;dE14p!YyQs&D z{~q9)<%bsSJo~q+8c;UL^nZhobI`w!znWFb1YQl^)uKP}QnjB8gQ$=J*o5sHO?i%_ zng0no0ID_)$!Utb&y(!NtmG|N&Ib&J#;XY{@Dk6LI#A2$(_J+hbv!r5&K>Oj8t*hk z+|e+0l=_s3W3UqA{~i=EW#s~FB`L5nl`xQ9?rt+|13?z}@$7OD?sy5<>`DB9oTW+W zx_`&`WssFDxrqk1)ZJ}DgugM6Bj@;ai zy}I`Vf+Sk}eL0&DEv_j7W{wa^=RY#3iGfQm44+)l33IRx48{}?LM(~2##;YjmT>zO zQ8;`RSVh?GlM*IfpNWf>XI!}kT3_EQF2Mkb`j-HMXrPdMYBK3$R;*8?bO~kJTU;2S zUW=V}o5lL(rZ-2x<_n3fWLyu}gb6{Z)kcjUS%60Q=K2NTz>UCD0NyNBLV&bmclm<% zt^F$wx3nlNT%N*2LG6KiC9J|zpKW=rHkJe8gK!bDsGgZ=9G{zuaRTmyPyFX2kZ3!{ zZHI}Uwpgi1Ajl6nti_DsOwY8e&+qF&HU*!1S8oq}D&FM$-bA9e)Q9!5TwGk_?~QZq z*oe^e4y1|Ozpp7?{b-O=Qd06tgl^PUY-T16E(ZSEnb7?595!+Qtf{!v`dkDexf;W> z7BJ#kPZuDHwB>u2v1~0~PKskoWacb9buWp}@T@PH@5Pz1RhVz3QS$i=azu79KzTLWACe8q8} z+mV$5SKqH85Hw%&sK#J$&dOXKl&vs9v~a%P4vV@u=_JX_!rn7LmKfNOeA`&t1;_)X^ZxWjU`k#XCzJ9Kv+VeaUC?z zsAIzC*uUI6i(;f~9K)r-5ij?JY>}F2yU)!a8=8(G{gIYD@||kEgIkcqG3=KTnA>ux zZWz<($c6Tc_I~;4pjGkD;I*>{$}v}T^V>!&%~|1IneX!JIrjZW{yj7DC=}C;U2_Q2 z{IV2e2X9x)-TzL&HpG^}3ECqi=8BF&+WNYia#}IG#?j9ZN-!EVhYRpoF%WaDeo6?W zWK@^nn)~DuSVpRD&NcSwX<$b5o1}jtsnsR9Xc3#I>oW2QRlDgr*IEzM!Xi^;1-jpP z%%;+QMIgrZr9UroJbL%Heh-sV(K$1B&1~v#^qdWRCu}g4ynSbZ3gTw5#|Np^ieEW^ zG~mozsq7l^0jqlef8e!e@zpKIt_XYK{`)Z*T3ez%aqWxDm&b=3uEr$_+~nm;yhc^K zSc47wo+dQz)^Y~|A@)(wvZH8--z(;;;I4Fk^ZZ#b@L*y4$qRKDO~v)@TuCGQXfV{^5D^`N^!>#&H-#Gt48UPD!7Pl!5!f3{E=cOyQHWPUG-R!Z%CcdDtxy^0a zPEANBu17-RqvxQ!>dRidt2tVPhlVG_RAJm_&a1x|A5ur=rcFE=d~4|65lP#dV0Sfx zwwpNfW=XZ~=y-jz0x(K8xKybSttg`0P2ixxz9RU(3iDhd_1BDlZ%;b5n<$l5lcNo9K-a8Gg4S*@@3CL32R z&J{xbae^A#qpNXa7m_RNL;2ONlvW4=qMLrSikz7<0u6D@mkGC%_CpIifd$088Va2y)`wGl$e?yC2ezxa~w+AK*@0&#fzzkfF&8}3A> zf`9i<6++HT`fIRfp@e_e+IaaX?C1sL_WzBxTogg??#~bqv0Q{z9TZ$3PNT|XShouK z|1DB-lcf_m>V%G1`TyS0g27(nRw@0j>sZN6P;c{Uv8V>XUjOga)N;RwR6BjJOmp}q z?%$mMP4TYtXvsIkM%2ICV^1(I^uMJ(a2oB~S_H1=u|&5)!zv61gg^P;jT^+ViaVME z@*mp>B8Kbm{{MQ5D9Tzx0jWA@m@<(BDNgwR8dySjxwf-^nyK9V-v|o8YJtNK)WLBg z5R+;juM93tDPS^drwLp4$M+st>{$t=_#zM+JfNimTAX_TyM=;%1)E-?!Wfrozk3D1 z1&O*yI;3mLg!qZoCF)ZeSotPj*}k{y-`6%WHYs0iV5kjAfF0!Qhmm|DMB;iAYm~~; zBOg1sDcR5kLFE_Yk+i}|e0F*_0)*F|9HP;I zC4F0WA!CW#Z59TjGnX-|r3l1N;7nL@e2F_~2+=2)cXt|1CL^Zi^^g(XPnqb4SGG=9 zJ6i*9I}oDml<)N}W^Bb)6DkX?H5q^Y@uqFFwQr03rL>?Bs)6N;B82fvAfV$NbNB$R zLv;F4K|T;!Rt)U?F_0?6m6+s(LSFBi>tfZrym!E@m&y3gBRt%B4E%Vr>>Ew$FV11f zs+e{Mu&=TR1fAJiUdc_pm|B0lCPj#e=>7Y<^69&z^SD=DY>TkpuIKx)S|ngLpC)X* zB&dGoyP_^Eg)s}eNjVm@eq>r7w?+FZYa3&Rm?1wuP6UH9X9PEM`rJiwbDKRkh&aL( z*>Vu*W1J2129#@|1mwDobh@ib{5X_rEV&Bf+?x9L(F^=}5y)KE6tMV|gfRqTxZ@wA zJ z_kkEjC6-ayVBUnx-3riKq(7TLj^3LJowdYD;EA2=`6Jn4>SI$IVhgoJT7 zJ#FH3Pi3yHJT=XAAeRKJ^0M6gIKbvG1l5YS7WkE>*3&ih?Kw0?L#KX|H5D(g`G>_# zIg}N2Zw*Wu-Grj_Eamj55=UGNb=4Ee6Jl_`GoSVmdhF6rSHRgb7|zy$pnWVKHjEPj-g+Q z85|TZ|9KocEEhkA6X4%geNl!;4i6X`BiyTHyZ-VI$tU^x*{LaL~mw4Dn~oc>y()SU7zALVCiHPn`5xDo|Vaw;r#V#ZP- z#VfM+A6LZ$5bgA#g_{;ocN`aARg;4=GFBIBK6oe>01OAg2o0qUa?3mJmr^-;Hfg_7 z58k%pcd^^}Dow60+qaBGYQA?nxK%o1kF%9LnKluB4cK7AU1V6E?oKwKr4=mR2+&X}DG5C`;=v(INq_vz;@3 zt~QKCk&SqtNcFL*4=Jf^vSwcl#G$Yi*=te~NQ0@Uz~?FhcG&Qx7~Nd(XdUO`$@zq( z1+(|2-I#l)Ixky=?mo%>;IjGqtKLwHEgv-1KcRIvQmVc3w|Uvj5q)?x8ZL5?)PC#c zXVz5U^b<|sh(JGS%s zlb()#^W}Qr26yzYjmkK$TAgm?aswujcDv`dtAPYKF_=9T22qA?5HrZ`{cOa}vY58IX-PTEnx0Dy-A{lmGOJ9o zP7xFPpFx`%rh{vag-oRbwAniEG`W?=G^;hF`Z7PhAlg1P`z;%sUNV2V;Bmm*Lzp)e zlyh0!)$aFZ3mxl0` zYs&hu1WkiybI68UI{VEhV(AjvVUIxNcan7q=WOtCi&fc>K@_~fRG~Aq5|}sg--tWC zpcyjVQwM&u=;ELIa&%PhJa@cQsu>pQvSZhG8NH}?=0J=S&>sQAz7xY|exVo?kTvpr zhZ*cSqakCi=kzLp1&IQh!oxxQa$i5V1S>fvH*cix#b#Tc#y>sdOdkc#Pyqw$0P>|J zPHFa+oY0kJZ8vwf%A2s;5fuHaxTpr)@`QwAlV;>B75auc>aRPO1eDd;rOi~{r|?pt znq;cNDS9ch!T1Meu8zavDqac#x#W`J|hr_ zOXF!JNjEO9X6~@Vl*pzTrN>37+fA>&zmy)F3d&vLcfVANxs?0LZjGPCaG`xmtbfp) z?aWR6nC676py#t7jvsqoASr$tPNca*!r;thd*lln2E8sJkNb5i{#;Xf{8aH81ret4 zHHWdS>Fr!LKCXEEw7<9MeNxnHlmO3|J&^xfr!{(55TTEf@qKd9e{&Y_r7E|g1k>Nzv0 zD@J}`6Swg8E4rIR(Y4h|G75L>J_y92hhm| z?Rf7@HYYn>gR-W{Cu|dP@%FAd<0MFR81cG`QAZ&?$QE zWA@jDuf~5+jnQAZBJk}Vb6;nNCa6?l46}(=-GEUbN<;*V+1k|G>65yDj#rde^VY+Q zt}|I5)$HrnKsQ8E3*It(9vbbwe|JcBmjhbHLv@%;+2 z$+|TZw6`liaa5$Q%;DZ=pJe}SnH*f&bkK3oqxBfLz9O@_=v{Clg1=B6W6g)L2N~8% zz4m0B8PKD-(wm~3_NCdz0)U(6d!{Fw-+I!io-?Q~cU*3K)s#Rioq;vL5beZ1tQCT8 zrm;B}!M)9T^D~HN#eHH$p$bGq86LetqVw6za}infc;$0#)v3Rhe-v#U2ZPX=pdXE9 z=sW43&I&FjgnBMyXC`HzC?doiC9%*B3Kj?SEyb+?I_=PIf8>yY zYQluEocQCi#9a>gCu2vi^mHcrXU6_Weq8fbj&_vV91yU}xF+oYKc<6UzXt-8LJ7~S zFk`gF*7rKQFpX7<(iTL7wDXoesH=byU+6-YX;4mof;F$A?B}jMw)?!qp{ad2aJl+C zw`pWUden7?vOlO3v1XyTFMraIV)4=waf8dk^kOlZBFK~Tg@rV7&i&rG=fzAsNKU5y z(<*7Dt=x(p+5Z09uAcxO5}wM8w}{|i&7`Vasf-I2UeS@~DJK@>`?~q@eU*o4ZL;!* zl(2C050gyiVQ!^TksiouBG#40H~))OI6cVHZDA-0{;S#QZH5dbUO>Ckn}}o=vEe0KY3c`oynLKUlA zqI=ywr@d@{?8dRidmnxF1V0oe=XvHS#-LKROK`k#+|&K<@-MQY$iSKf&nC zG&knuk7eazLqXBD^PNE_U*bHM<);M9Qq(FbIl0n2I;eq12`|$M*jO4adsxkiya?wR zFPP#SsE5om_hWwHFjNNKW!Z5r-MD9}s{S+WgDl7A!AFgj74g4PZgHm1v(YZLY-Fgi zcS_N_svJsqhVN8!$Wsw3?k%*6#U)?Nt&d|cnC9#UI_u6;4oHDTxAl6(kX~qzc)Po+ zR-K=>h&ksUw99c0<(8((*v$FQ3ArQ}tp=*B^-u)jLj2op3n_(=Is{@Qr9-gT)ub?8 z!k_3h#46*=>9F9nIm#1m;)sSBj#Eodb{)ZwgKaTMt9&X7b4c%Jk~?9#EwNm(AMsh8 zI_^8&3!<1I=QK&B&3PQ7bfddZwdSqXEr?&oS9`AvHr8srZhT&0*(d0(5CP)tWi4;x zG3V9-c*5y?D9xOrwe%01-GcF*kf9p(1=L(Le&-knUHLG%TfgNbTSpzb$_ z&-_;0N$2=s)q~4peZEYAq{e=c9aCA60F%Viz;_Kr*+;+ z*!8Zw@C&Yx9k_*i-O*IbPG4O(WJge)apGq;mNpR<*%EkD=U(;HVdAs zrR4`rJApZ&XOWSM2epgUi{~FP%cXl57ZBG5re^ts4^HE2zf~Z$GaAhK6J4!D6m$2M_%*ya(@~p`c-jcP`MRb1N`)o&h&B<*QKZY^|m_j}UOL#3ruQuOT?x$thZgvoNS^wr6qbEQva z-LHboufkOfCb~<>XZ5s&g`auCRnL)YH0gcbX{kE!j_BhXf^=>RR=k4QVk|Dvsq7*B z_R|6q3Ld^rL8^3ik*n7kc54AX0k^Gt4?-5xKL8($e#fN<#QrSkg zA3`c?KeGC-n{=K>xh+@Ray*MjPli%wx@TSlo>X}R|gzr-4x%lP4MO`in~=w7H;D1~HDUA!5`kqTbry7u@iqjZwr-&!W-tdH~p zwTN~rsy%S;@MU}ruRS>F=zq&*q;N=6T~1~uKWo-2rWcjEO_6#{KQv5SU0qQu0)JCu z0qOr&D@eTX2#Ylg^WlDS|d99h?Y^?VfAoo1JDc?*OgsD%C zn}2auQ9bXda`UJk5`2k|`5fE-J;zsDB9Y#4aqTx>UFOVrUg*$e)Wi1z z&`C0cRdw#y&bznlth%{duLjOB;NIH$wCCN&dYMtVOS6+JGJ@0(OKxPk;J0^1M@&e5 zQVK;ouK#_%1|_mSj|WhedfW1wDc#Yy&TPZ$%Yu$wvE=e($z?bJiXO;FBL`!v`xC;9 z6{^2HqaJ;zGZ;4bqW75d;+MyR;+r)Nekj3P5=4?jF?=&dCFX}R6HCnr!4cdB6U>GK zX}fr!b50i3?q+N2AaScV&g=}X#pL;!WVoy|#D5uHhO~st4zJTYNMx2Qz3n6*V<19B zkbg1!D$md-`DpOO;jUaFf_MnJfLY$*YZHM#bJ@KO^1nB}ixXvtvNqdCy^fj4s$8I_ zGFgJb1{+=)iKlhC*4jLEpZy9H^c>djewx`v;*a>ayg?5ih^36`$UN&+E4-ihJ)9t6 zr%Cwr+qGW3d?J@5P&YGqH-)?0=Erh;pN2w5%j>kV>d#PhH?^Yx1SniifHs;q9{|p~|>=!cy zpWB&|atyPyqJZmB_eE6X*o&9r_H7-mg+A$Vp~mG&=uKFCNHF-)s$a@Jc&aZ&FvoKE zqhL>($P9DL1beoAw+;OIiU*wB?2Zb<2Y%_T$XG{-Q!1PNdrS!{m`J=g0|X4LN?-W& zIf9cyy4_f$M5?06=PdR|%D!>9Mzf3<$A732)@KJatZXdV0-W zDW)vod>TBF<8CxhD)BM4c*L6DYUnPXAX{9u7+#dwr!_4t(L>3K_qbaWUXcF&sq0?!kpRNe*7>4_n4? zk{$v%#440EX8I{!>+$82Vi&1I!8q|K%Cgphr)4|*s~v51^wID5TewuTys2lCF{h^z zaY?6cD&yRV6RAS^W#1^WHM-JWlm0MX|`h4u@PKf;p z6L2QS)m~CGkx%=sT*b0Nzo>$!!T3KS*pM{?SuX{yMA8jG$QBF+GlgsPpU&YFN&EC( z0^{Krb-@XdcSqj_F@E5&;FT4!KJPsdHX#sKFrYSxaB1(VZLLZK@fFd4tZM z2~WKOkuF6_x~p+~AwFRPHtv_mE1$m`bDKy&zvokNZ#ItjH$7iH{}jmspm)-gpfyhb z4x?}a zWE3$N5o5xj!C)-kdpz&Y@1NiN#hEkb+~;0i%k{dh`}DvH{;T3?rCp*!F`&z@&~ZH7 zm0*HI_PIXu&Yq73b1)}cZt2jMB15=}$x))-%ql%E6Bcqc?)ChC4;BL9Jpbt`MWR|A zFhR80{xnUWM$ZF!f|K1!3;7+DIeruKLpj(Dbj7R1V-QY;nQM^9;u}flMlO9d z@xRt<`$&B(L8@A~;|0$`sZ8bo2fZviIy_}aY=3U8^@teC7A5C!ri;ti;72u}0zAD! zH!}q(KV`o^1o5SJS0|N<8dc7$1MQk5H3l&?L(2Rekpjl*bxj zgRE&n?0eM)=1)R6eh&ub4X3lr2#OP z(iQQbcYhaSY}qq~XVs(N0Lu-0bZ=2;Z`z9*1hp?X?6MQB*Ca8{PzXGZiCUmRxwBYW z0ruVSdiq4pXQeP>T&sVDR)QRs165LEAX%ghDFgZnWUwD87S5FI^Jj$4jDCh&lDdIL zhY5Y4JvW#3Lg}H!@iP&N^hRPY5LWk+m1(R|W(ac>uLglu9&kCjq%pYUGtvQ2h`dUF zt;)O!zc{!n!#8{Iwi*5m5R-*UX)h1+mPJ$#zKlE#2<>M9Ny%<2^4@8$e8fHz+Mv|6 z*gK9kQ3=U%OK?95DAj?+A;+DYnh#H+J0m&|ZiID$8qke;S}j+V0KnOL2BT^~NGZ4p z@r`yCYpf2E^)^cIWf6s&fUMJ0mrn9&LNFY9xX8#wN;|VmL2;i*Hrd|v% zNKNTY<@!?k%-JC=BhY}QRG_q{r+=km+S$M$gaq1|{EHof> zCn|-*Rxr*%euQs7aB@2UUILtAyDbYzT>BKBWrkr{iebAFv9d@49hyM5eJo6uemeyb zl3}1VwO^h1*<;K|xffL85JiqnY&b8|uTL9zK;ewizt6D!4}NG0-%BBQK>TGAVtRY$ zey{&+2-sVft6Lz<5@LoLkE_V2pqkw}$nE3~awoa#>VvHMTJSV{LxSX$df;So#SghCWXoiATN}mSDk4zR1uUe7_F!B?estoVYIiQ$S4UWiOLH zBX!Tw9cMcCGhsl&f9pGn1^+1OB8Em0ayM)1_}n1ODI{zX7|@t=InY0D&E#eU59pg# zXl%KqDaCkKR>9kD8+h~AiYQD`8K4~i@K3}VkQl6DHi|skwTLY*BIK6(-M04UQepS$I5CN= zeupNi6)ccSxax(ivx2^0%6Y~jgHM6t`j$IIRASc3&hliy5MjVsro4~~Z87;8rw&a_ z^dM0nk_vBE`zVa=8mdF6KAYI*@(G!}@H;9jDp$i+d+qn>^exnnCxFBd-(wdb{~M0PZtyy8$8{hh9MpZ(zI#!0KSCdP zLyL4bKG4CY)^1{c_ZAD?U`=B2j`_IgS5Erqk^@-^0z!ZfwXFG(pyAr zzYtfd(iyy5+S|b!G!UB zw4r8e&sf4N3;DrYo2yN>8N~hGMkHTS1Z8x#`MQsc*6dhqdU70S=yM*@!Cb?ZFW}~a z=$uV`gf0uXe!oMb$5Q#X7cBR#dZurt99KU>KhxP~Z0MtQtpL0L!OaZbdqe`Cf)!oy z{qVbc3a%k%dm*nSSBUXC&%W`HI*l6;l1X3;KZby)ZKC0zT=eK3X-(yp%rn92 z!vo8@*WlK>>dI_jDYEyws3y?QeBQR^)B`=Rl7GZfuyr~z+%&(~#5PT)TjoJnrhiRL z+=OS250Ki{k5q-Oe1U+ylyfOSX=m=|M;bR(_xXjJ_k&z$EZgDM25Kh6?A}VCrmU4+ zVKX(RzwRT{`ox1~dvojvi=T?4$u^{ZB}|!*Z9V}R{0C>jBc%_!N__8~#>Y|l_b;H|pHY`Q zi~v$GK%`?qSAhLxr1TxrTvS=u0+flRcp4E`pCJs_VY~{|N#GfIAd$VtM)EFc2(NsM zw7!gUAFTjYfv8W{PFvl$8vCE1L@2BbpsO^x4`8l{mBtI$n@8nqN%xsvQ3F%{-W~_w z5otS9wZPMBpY1aSCjY?mf107#X1FM41RS)#D@E*<+|p6(7zaAZ^+vlF1mkS)cUaVn0#2Gla{Hw`6~g5QSE@D#l+og1ljGxGLXfFKhx|=vf_zv}CpLP9~%> z4&gF{KN;qS7!TUcq+9z}5;r`ha$*Kh5j`nGkZrRa(@aeF6zc4ZqM!Y7|~p5sjD z&?+U#OwKuyiZ3M@kp3W{Hg*JhSsrwRUM=}^)N_em*`)`QUlKzhG7Jq|Xmbbpw$wUd z%-v2hh8)5amN~1?ARgT1M7JmRhGKpZk5hw)Sbe{YmfLf+*@z$t>K=EO2+L*Iz6^bi zS&oFn&%1SC+L&fEAb9Y$cY4_~=yp5bb7A{(FKz6oknQtfN|Pa!i>O-9aRJ*Yusd;r zYDy@hI*BiGzYYkVAep@<&+{EDxnF>w|A-4!%0nTO`&?BCN_1IMv%&fEX{0vKfRNhb z5SHFdWh2_+jO=V4?-m7wvf+#V@aQ5d5}?E%KJ>#!eNOhwBtlj{U~&Mbld%7=7^JNu zHZGo51j^_yzpJwdyO~-Pb89T7?^>=^ak0<6sJ@qhg!J2AsQuQo{LZ^T4b3ZP)!qL4y9yrOV0|A=wlV4;%*DaWwld zYr5e?550i4-4-K+M~HSTPrL7NIY)BOXX2IRAHy_dd1=l^f~U*9=(xJ8i7!q@50;F zmFs;lc6-I<#g6IRB^7;ez2C0$>)B5xx_(~+Q&`;C_WW3%&y`o_`0n|fes|Ji<$;Ae z2YR%zT8B{OJffv4lrtjRoHjgI!;SX+brJ=qi6XCTdy{U~-dwSvLpN3B!hZbl+P)LN z&Y1r|o0|qPB?FDyEW+mzFu^qmMc=;?cHZT?Os0>Udf8{QH-43FRaO3#I`1+PC>f+% z8bn?bzOJ6q^MC;V*MWzL*!R{9BKxi{p2@9qFHf^jVxJF1gDmW^LelDJSM4XNe^bj^>KCGBqOPZTnY zw}ipTex@K(e_FF!r=)iI zvgw>6lJIkFJvZ`%L)N{59TT`0DV#+<#GxJ zgU*VK8UFRzb-X}dygGX>JwezdwvN7m1Fh5tv;BS*t-@z8JAI9=N#26R!1b9Y)$_C9 z$hFse2KhdT*fklmRg#KywXlt+P(rlM(z!`ywAxN%{IOlZ-a|I-VGSj@C#KKtg+f-J zLSMy8aLs&H(we20E!jTc5m8VXce7mz-hWy-15_gt||O^X61US=CrH)4Cz*Z*GJ7NpqGKnbb1Ua*3%}O?$??{5=z)* zu478(W>%TCj-BBBU&>*obY=z`D9NkU@!R$|D9IT=jkNn@!i{%htIm7w|XJGRc&a zgf$c2#{i+#UKon12dtL~mi$C-N_}tBKu>ju?4p?;XPDAR0K}c|aFv$qJD!|Tus$@v zuIVovn`t+D-N~#mp?hT^E=ma}o;*~;i&Z)sYG^k~bMfLPpBtYS$6f1sgq|{tb6QKt zcQN}WHXK?w)&4Ek7X&K)930+0922!m-h8ip zbMR)q=%MqqXP2*+S*t47wf=(?<2mN;&_em0x|2=+bg*;A%^G$E=ZNai0jBQo@>sskznb$Jy*%joak-YJtPt>uWo)YMtFw)a0{H+CXGitLeE(DJB{4K* z7*9C}trKPvnrioc=bbuN&HOdu>E9a^s&5-2SZ(6UXma{M*ERb#8g?1v4p|C~XV`yh$eu^D{qk4hah0Upcg)?SG6m^T z4;0VoG6f&7Wkjjuce_aL9iH)k0_QoaiKmABpr-!mj&Ooh)&N5LEDWKuxJEoS;&EWR zxDpWS_mC}@Yb0abcC;~>Xm(H(QpC?y%@w&8lT<9k;xt( z-OA^5Y0?z=sQ_1xQ0`FZueXImXbS3f{>2As#k1tqp5bE!*YbbgkY`aW2u^Z>cEak2 z)jHm<)J_hAanYI$^$a-5q{JgVJQqIbwdu+F-g@U!aH^U&Ppf2aA^f464pCh-mpl|K zIxpEcnicPD43o&BDkk-}5VKkk3h&HL2$n4{d)jJ_r!()Lj7Uy>cJb}vV>5$gH(38e zM&5rLnPM(SINKw=B$BzJpJZQ6O6!}C(u&zRlQ$iD>db>C7rJ~g;g!T%L7z*nQ{6`? zU*+#}u{<*#w>P3yjGor0w%?uBDyQvF^68quetOD3{*R+MJ-q|1Pv*2{eYxLunXjwt z%}Q*<4R&2FDRN>(jzmu^PVsG{a+lxakDQ4I zbyQ4~>|RO%Iaj~4U}&yuco@2g5& zx|Vt#A`)xA8>ESA(BSnKdGqJA_~!2nA3M+g>@~)@zajVbqbXCcod8hA_!l`MrOEg$3vdEh^O(*OPTxyYg6%AB1U9v%xL7S^5)Q zi_v!%Hs^PvJDP5lN=%pJ6(tt?8$$4qN}gLCX)aAKiqL~gYlWb5(#K_NB3VFQ4ziD! z}w*y~J9ypmL@m>SbsPp2uLKDZ428??dUNtW>`=mqGE-ev5oO{X( z*}f~gq(W<#s$M4a>n2+_CiDV@TCHU&V`G=QK=7p`ysLA4#l9d|tG_^6jp91UqlFN( zv{^s7y1c{oD73imA-d!0z!uZ-QOX-Lu>4~u5HeQF7X{-Ao?L~42SlX1?-nCoFPcxy(T+ER*0lQmtfu9RYiA~S-FAyUH;dh$ z)=2i|5HZ`91spVq)Kf(U2K#OcrKtRxdZq&CZ?o4MU~j6nbLa(9+uya+WR{_!EIF?n z%-|4mo-_A^JJRkE!!Mxss;5y?uYlb}mfj|%)AZ4K-56icF9-Q9@?hs8@|>5FI-#Ow z%twg>9RevI81uSkQ_AC=gvbxq@tQ8+hp|oVA8KYITItZ1)%*LcpuYWXMFTlM)iWgn z^u!l0>op80l__`nznABg7!#ZEdW~=~@YVQ9oRI??&-7q!oBRE_Q+j0}H7aO}3Q-gGo1>ib*X|9~iffQbXFsouZ9 z@7I@AzSfVX<|udXJ*_VqLSSD>UzK< zC`lG#T0OBsgLG7(iybws&6dt~@Gn~-9W>2((w0o>7DO38yUoquF2%Q^$Q=I|8REy3 zSdf(K<9XW2_eXbs`#4CbwOBq%|z`7W(q?ErYO-^x~n8IgOBy80C(Kp;YuGo<{ zA0S&Y{9G}5>0{sxL4WRSH{Hu(U^f&e$xMz_a&3*s^qh1X)PjZYdeL;c1sf!@I|#o- zYKDFg;--o|MHLcOdbNK44aH!jkt1BY)OHHQ-DuSH&7%~ct}1-a^93MCaq8fg^pYQ&KM4apfF?AHuN(Y?z03B z^RFH{gusKno&Nb1m}-NAWkn6EukBy5^ypR<$-lgxZzJV|9wk>^e@ZorML@YL`F?Vdt!HdniP8 zY(!eIF3yu`^g%~?nlO2xU5B3tTO1>MdAm=G{2~bsD?d8E^4RAGki;xi)d@o4XXSHp zf0Z>S8GEz^Fdsa;(yInaxw;A~J=T)fav>6>rw)@y=UZZdj1@IdHcMg>^OGHl5^GLf+ci|qm8>%{qp#Oi#2cJ zp*8;LD&5+5e$C+R?M!=uge3xeZbN?F@j3}lS7?W{vDUfFZPu*^4p}Rly4N`^VYNhZ zs^;r7Q6zFE)GERLmO9^a8cSlFfn-@u^s4QhQ?fveBEhUH-iKnTerTjFzlp zmQf&&{sVPr7@KH7R%Ye37>4ytRiP)%RNNf-@Qyk&$%^rxB_lM$LrNZIm8CKkz-R{cy-2S``M z{W6dJkT&2?x{R!TA>4(U>s~tW_gKmIG((e;zukp|UF z0(qE5dUVO<{By_p-7Z<9iW=1n&pgjYlH6F*&fa$aN;h=UccIjyQDo?FkTM^dG{+M< zcKd|x*<{reAkzeSr-u=C!R^M_Sp@3KRG!cRAu9S55&frs~n&I zDOb5(cFX!n>bDKSzH@2)biw5YRc#(Mg$!DRgXH`&T-2S9#4K&ih1`E1$>$jT~UrPp9~b+e#6wh1~}i>nC}dw*CG}CBJfq zbKZ>7*wuKHD}^Y_H?!-q4f+mf}rd~Sr z!Fl234Wq8U54WXjd|Gg#L#eDf-rB(X>?Nb>r-N_8 zSi3mI37lg!3!I~2a;0+Rr@St9hslM7T@r(k2>2k!(#EZGga2 zQ0FI8LJpHvkb9fwe)H#nJ=?5V(Yjx;YFIyhuKVn$+We&^EoP66?-vD2 zeo^_LqTa77qE9W~*c4Dkwpprps)g6FK(b8o?xg$GxyafiZoGXn;yPMqy}1zr|1|t% zcVi*%hw!dPV;)Cs2qa6wC0az3V`_^oY@|c(v()E7UMKrt`{Jxk_I|0SKCw^Go0K(c z7pkv;8YS|UH)_WI^6_Ijm&ex2-Yv9Aoc<0ciF)BUAUY+Oz13a61qPR^VMHga6=}Rq zHv$=y0A*-RzpFZFJ=NqxaHh`kwEV8*U|Lg4Aom4-m^-atJ~j|!{Ssrg*yQS9ZEc;5 z9B9kbtJm=*N0p@Mrg}fC2wYHOZ+V(&52u8{kB^xRVEP;2Q^&`b*}p0h?qZ+fDXkp# z?n=g}0!v))jQq6n^|a_Kq9H%G*b+zNFJS}t76a?LxM6eR#$`rbi`e(-$|w<{={x=4 zA|#K7yf#)>VE^Njn+o@^dO6?qv{>p1zhf(RLIRAf7&B010`c&9)?e}*%7V%=%1~uP zWqW*7RK*ju52CgUgks;r!_l3ChXyy-UUIqhVPyP=i=M@k(}E!x8Z9fiyGp5v9j zVi*GqrcC4mQ6?ulV$>#^E?#J|9`hOVDH}I=8Cc)sPi!^G5Y?F&8oRT7?~`)!LDs%& zgx4RhdN@@U@-yc(d!HnEjy7~&XC(GeDw1v!b-LN%JP8-$Z}r4VGv3Jkd%ldGIy zz#)$OsqQR#!=R_@978GTqk+Y2o%%gg>%Fj!9_fA@4}WW?ADspVLnU9pL(Cy_K#no) zgw<}=f?^kgj;SloFplLmuj_eMzl5k>!@)^v$W+qW+m`zK#xy<&1r@;>PfVg%*cJ6F4F7nXQXQ2PZwNir+z`kH35 z$2gL4Y;lP}>E)lAe+peRni7yfKZ=%>cxS_kPke??IW%a+jZRl#1-BAw>h%>{K0k|_ z-7W7bNDKEb0^Ru@2(2ix9aln*i#0}Km`wp)KtTbl9pczAXsRlRFJ zBs4gOpKFo4;AQklBw?+w>`p=NcGehSFcao{1S=-|Rdc59L&CVa4^J4rU)!M#bwK&dxzZqIYaBBKVrO)=PWIvUBif** zrlt-mT`|tBS%E;TUc)9@=_5qzT_C=(*Npr&TkFnBIwmM>{p^0{)l}ZhEpVC6$`{sT zbo{iX8xEqKtM!bfJrMW$vb2f{oDP<-xeO;1)vrLp#>GsO)&*%Zz9it~{q|^b?Mk{H zBH%;D-JM&yyUsW|NOe0C!Qid?V_Fl6AMbcpk|M-#zL=uZqvl)$cgH{m^zvWcm+Ut< z@ic={Y}CM6Iy5w7iFE0WEtdFKMAskL&s|5m)6CzhJiXTH+7(Da$whNcO&N<~+BsHJ zn+vV?2woGu5VZ59`O=_IWG&FLg2L-*Iby+#g2}L&5V1VYQs^s=!}YI-ila7JJ2((; z=UHXfXjm~8cZ){$eOLjXGZDdg^R$oagBNwVjJh)({AP>$3}Y zgJ1U*pndDBk>OB$btib`Ub%~)m08m;Pl}tUh)7Q13IilvI0T<-h}DJGFXWDI(YgOo z>zd2lNL#86344~OmbhoVGq|_6cYHz_jMfOU)4$mb$B4c;c026%AJL)bREX*0%7fxv zH0LZHM>{12;pa%dMW8h;ILTrnxRBWyoa5mx;vi=_XM5o_i**T?ce+q*e9 zE?zt+TVb?%rlqB2A05TOzyEwgY1d`U$IyvNe~5g!Id-m;0a8cv>KeOhlDylR*SqL& z7g^KdqNq~%Y@6(@dlTY1b(og7$T8;jz%d`P3l9Wh7Iqh#r^x&B*h-}B0u%q#=a;+W z+Jx@-xnkGkzTeABqh$&NEEe0iwCW4A*n_JvC1=6VtgD4f^->djm3nX*5ui5Y6BSjW z+GRj(!*}NO(oD~^&(!?>B^7B&(Us;qn~jY|b{5|&h+|vgwhJ#4`g;l6UE=*caaTnb zDZeOl(ceN7LMuXtz>w4`@hE6!*E=c54q;?U*Ob<`%y{5bqZw6$$^-eAJ`i-@F9RK? zYiT^?=VH&`csRSXc2(^{_hMTDy8DFMDfv;`#bdWWQ4T_2k+59^(sESj9Tc|P3NFqjJ1?i+nHe~2=#vMHRR+mtkY zxu`0c z2uixC7cz$cAs1~426X0V;oNE*hfWOeYU{B4^(X23-cq{%;IIjk`*Gv zD@o-B4kyQmO{AuB(`>|8nl}SXX2V0RD~@mWx^e-gr4eZ=8v@0a@y?F2dSqf+%@GKZ#3b0%MJ~yfzRFrraVJ3rCVzu>Is@UBwxI)CP2HHr1m_}I0@ZY2JT9y1 z&Z`3z*NFF%rg>No^?TQuc`}hQRR54kDd_4u@J7X$ePzDc0CqE#Tf8|WauPy!qp`R~ z^ssEtuf;*<2{U+@|8`ov61WaXsW>o)Pou&&S1ZxS!T%t`HloB5 zPmiKjy4k=Q2cIV|3`LSR%E6&|tSN0VK_DgXU;2#k`BWYZG&VMx|KDlho0wp?<4gGT z%uL)TU`c=nV%NT&T=cF-=k3OP9Tzx&7V@YRAu=SzCqxYadk;QO`fO*9Yj0kI!IL-o z{&$YCnVEOxfi(>NZX@yk`&kZxCvk&=P!7!g(a*qgH3m)$iM$2v>c;uf4*uU~=8QV_ zYPQG-i4h#B{K~(tiA~1s)4qLTe0)iCi?*D6$O{AZw3!Nl{CpuneuD_Ghr!=&2*Om- zHYgL^BU>t$eg8DMep;m}jh31E4c4)OGmRvDaW3`n=%^*z1q zN|~XQByY3Y+!?Fp%kQSuu%@rO{H;0Bs$QO*^tb$1qhr@@ zdij#bDxQm9Yj<<8*41QahZ@zeS&5?eVI)P4*_6*G2EZcYq1^*?{;Dl5EpA=y+wDnh zRUUIaOo5T27lSbe;}yvW{HFN!c8JHYGTqVRKQ@Wc|Ccme2b2HOUIvek!Zlf{YQNr! zYPcWwXmy&he;YD=5Q!!{mPKmO-n@}M)m1IvEvB>w!j z)a+YU2XEk?!X{o+dZE(-Hk!7kYUwF90>E)O@wfImNX|`CzA90iIN`-U> zOZP~k0aYJPPrJ>BHFysCd8wpnmFjsFcC_@ghpc#2k|6sRrOtFT5H8R<@kxB{6cVvxnZ!&US{kcRfzDT|^r6O{AFvL-;88g=;vz`B#)FXQ zyXs?0RcF`$t$#;fWmxSFoJO|FX~4^%xzG>`BEYU)AGNnq_p!;!CH)8?%e^8@@Ljuu z$Z-7WMbr)AQ{bTqsT<9h;4T%5kex5Q3OTvP+~`Qa+>Y|ni>rbTO$+}&Ma?iT{w zWh+i-ZR>c1U^;2#bF9>-%?GUOFmFpN=r(hmULD-kC3)v!S}?P-vjG#mfu7F|o{c-+bC^$d z8#ffVj!#8cCT|q^UYHUPFz5dK(v7E6FKJp%J7x2pW~iC!p1-%pUxmVfEDbqLa5t-! zq>b~05B1b~YXb28s0=ollH$084`&bR*VMvAA5PG02b!p9r>uvC{?CvgkRjQRB#_nM z8;B8K@%InpW{Lxj_Fw5|6Wiw{pJQl$(>_*E&j(xOOXWCH?n`t2srOT-Xa}$I&dyte zeVRhGKDeH2p6#_7kvst)3<%^_k<~sNw~xb}EA=z?i>^Bhj-gNU&ITm4jgauuElrLF z)s3Dw+N!iVUi%Yky>j62c4G|F63|Su&FItoz-RM^t)^ z3+;R6A0Pk`m{R5~pYoX+pV+F}+1X*r!cMMYTC`Oa&9TYAsIFC7VncN8D%<+E)7n;t zgow0Pe<{RKSbz(56ij|ndGP)hC8|Nsu1y!4=QK9R>Jf%?1DRdD?*80maFZ}D4eUo` zLhMU@w_Xi-_mi*EKw6TGu=IMnlH~@2r)y4>;bm0WaVH}Ikc{!!9VAhIP<7dl8TB7 z9u}BDl{NDFW|0sSszjQRUvRQp=vecobx~x}M*nG(+(k&^Qd2;}9j)DDL3mRFg9Rlz zN#e}Oc*Z$y}jZX?C&s3@GgQJS|Q z%EC@rlGkE2SBajaY#|H7R(0C&XX|2F*<&qhb|(X5)ziW^%;{jcX&XtybIcXWP!SOk z$Db;nwakxg559mN^307nDjePY6~h=N_(?OWxMnW^yxWW;r6%ZjBXe=&277|lp@XX{ zNqfbnm!FH5*opfpoL1u&_lig6cd|llK0SE35XHJ{ijTaRKBlqju-W*LqSn>9bP3e} z)IySmDwYp}-8W2BydO}mSgU}b_*y;Z7Y*|>iVZKRHk|0(?^Ie)QrG+yOgBll>kic; z`dObJHO^BFa!nswwd5zgDan8A-hz9g`*ZCTHgK81J8O*yC_LT9^N5MP@e0P1v@QF- z0==ttAjd0Wk+ZZ-Ym|B@jXhWh)w z6}k@0Eol{2i3muu{*A)=1_$S)@4oyM06HX$tAqFt_YSvbw|UHD-Y_Cy^FxByxPVeK zmwD=j1tB?sQidkpp!f)Bn?tsx4tR-7@1D;6xz#KC!*1_AFnx-97JO?u;{mI0cX^2q zlBSJS+_s)?Z_Dkrsko``HLOyn*5)nZ^_`kEMb6m`gk6Lox*8o?7lzhb6DK>7TSiGhE_y7A?nVP-0&RZ@_ zWJ{Ws1<8Hl|HXmqhFhP`M_U{ts&W|7gP&D~`$s&icrJfziPfX=e;D2pE0BXvCXp0q7yR*m zKcy|+D1QK8_?g#3LHY-*l8}2PNQ}ZcOYIjDB*}mNFU(XQT~#@@lvMs>i#CxfPYc=a zPro}sP6n9Hf4{o`VA>}MsrC!EcH2-cIEx=vB;{jEAVR5Mk(80C_Zss_d%HmgV{y1j zyFiwFGswmG_f4?&ytA`&Jth|%4o{E5GY~=XxH88o{C#Y$Kx>H$twruaFca_hBE*w0 z7Vdgls;U665!K1(ldi1di5qq>C@fHu2EIUM9%pD@Z?;>g=HGvSZ8skiKI?MibX6xm zyxh!vw(y`gVag^!$#=cDKuThDD>DJWC7>lI%*V1HV9Pk)Lc84fr<|T=YG1cc^QP)m zwi$>i7k7rXAXnA8dOQ@sxnU!Ag>9>VvB$x`FU6}|S6Nv(eU|w*-)tRw>EYzR``a&$ za(+LpT^rRFYg$~(T~CX?W#bkI1krP>x>wY{@y$w4TmE?JDtBxt1TVTO!?+NFw=~2K z>x6?GyDsn%I2}@$?KM;)gsD)}6d~456RcX7nlgc@kHNG|tzBZ=&Ut9!f_J;sM?3YW zP8Rk&tDDb3fF1XFRzq_W6Zx21=riq2$kxaMMB_h1t^22AsjmC6w3F*%%>AZ*Y+_l8 z(378pb$yDp>?}}Q`;V|~q$MHoq^(46=X~^JS;$egflDytZMC%vgtWcns1gbxe5}GG0w8C@0Bkdgq$1|SQ(@21F{;@vE=ZMB*i)RXew^i zdx4bvrr5jFH zM;92_@2|4{vdU)H0*w!on$-qN%>t{Z6W)iZ0R9IcNdH}2wW|lSm&&gzwy%1$O03@b ze{{f8>bKtHvwGb9@6hJ*?~FfS8ajfch~9+{+@f-!%o26Lne(=hmJ9fr%j6=MXh}$P zRE+&X{w)giYY2Wd5n)I<{XVIjo%IM5Km;i1PN&d7f!L_4(5?p(WIIHF7p(rRcS%%( zkLskfq+1#y2sVKexCp=iRuAad-J$=10erKr+^j>GAln5cfhjF)2>+A}FDVzn@&&`F zDPQ?SIHXAMoqAWNBsnpOTYxBDt29BCAhSxXZ+uANp6#_;2;Vac9R$H^YftNbM(9dZ zLvuoRFTaBdkB!~*c<-_eaHXwjIBM&Tl6sfRUXH*NmhgVC`@z!Wx%Lis|R~771I)Xc<~@}+ieate3ZMnEi^N(;MqXm6efjRGTJb^b2Z4l^$9bi z!<%zmlE35wA-=Ds9}raQ8WB(ul(am@Dw@2JfeF5^+G2oh=5MvcLM6y^h@D20D)Lpt zjyX&vWkV8%DnFHGG3<52;frt2M5riHLliQ9S~e;4AEJWJ@uUqkSnj&LDmIe8)ex(| z-)f9q;%|L~jRBbzV&^tYcb!ln63lJJq0#nyqC%uRxZS6}Nvyd|RQeC^T=Axy?vyJPQzjPLPF29CY8y$)QRMJ4)<5@byP z$`uBvcFpt7e%7J5hwcCejPfz}I|buNt{G?Ilsk@GYGN{sNQ-C#^-Ohn5M8Qu@k@%< z(5x=;T5_N57!4r2!rI$nDs}WO=oE0VC4xGgwvCFxz*5?+}hl=eyM`J~3ZzO3w?k<0?9G&l!?X_6u$jWR#E~^|PSN!(%$D!Bw+NZ!#=r&<89l zl)SpMUEZP)fJ~qrW)mG?y`|@Z_nu(kfp=;`&WQCZMoaVN7N!cU2EW00Dz+B3X^RGx>d2l!_=I~u^elXLO${_1u zaG5BR_kRBbEg}d@{@oXT-?gd4diM>0vusqatr{RArRc};(ri3 zwWqJ=+#+hR7p?x-I`00p(L~oEZQXBKuzYcZ7D^Z;B72{lTmL1bPuQEF*6u^Ht}DQH zRYS%senPOnUXf&%1rKjzjG zv{-4I|8szyZwV4%Qqk1r!Dnu?(7+53-Pw_%Ziq&E+LvjFw96r@B1gaT_g?M3k3Pq$ z;)V{Bm%$qzJF_(%laL%A++%fEb*YxXA-bOtgFNY8ZTM@C9|NCTZuNm97^` zd1zf7c3F@(<--&@1Zr*GYF)M$N)OA9uB3xC6?)j9Mmzr^2Zz+@(Ze>JYxBMqEgHp$ z!Q9FdH(Mv9(L_Dq*NUg$fwiO4x_HXItdXUenWFB|S(Vp}(rR>ZuWP&Ed@vSQimtwD zur@7?A1SHb3cYyoq9Y|`z;N4H3gGq`nc~83HLajNI zujJPiG|4(TL3Ie<1PDMm4Sllv`P_Ej)dlD1`HvYL<`%B5wjAgG|Lg0_!`aIEINnZcOgF8zbZUti zwAxaN+DYD-+QM6ES1D0bT@YLBBDxJqP+KvzR7LGeEur>SJ85f41Z zvIdAG*O%&iZ`VX$``1&4pdMts6MXE^VN7Gp`03}O!Qu^UA^GUTw{+Xo&YsP0n_v(% z)YQHsu0x-v5Q($z3S;Hv>BVEjeChN8Lu0NL@%-6z2~r=aiDz32I`O!Brg{MWC7Alv zmQnHd?)PClsRSA2j##;N9HG$SH8n3d9bl3|c<``THuy&Kj8UB*^2EoYQ%C0mYZSnsY6oVX+6MHqcrp1=PH}@?_9a2 zWe`o(r-V*~sy-2fP<6}FR*I$*d61I~Yr2(z(=n>j$`X5Flf|>0UmdMQ#!4uZ_Wmq! z=dx+LU&)S7tllJU#I(;$DKDlI58>tz*yS_(&ckD6#F7fRZ{B`b%2Z+jgUXNpRyZ0u zF`_sfBpK8VPhR8Mn3|58Xe&I-Z8p+L67~W2*Hd<`H*Cd#Ew2a%V)li?=AihDC|Kpo z!pA{%5Xp?~A(aljbm!HDF~Z1HH|E!w>f8K>1d?aopMhSL_J&R7I$$=&!_3T6GoALJZ&U zsm1MT>HEGENc>$}_}92_xFSgoCLHaEs>UCquwm%0bg`&2w>f5Sq-}O3CXA-0+L7bW z{LRRf)%A1L<5Z)CPnXRS@m&U4?~a|L&#lVGi`D>sgSD5{CY}`3^Qczn|F%a+n1WUYXcSJ>GYBYCinA%2#g7aw@ZDfK)#AHwq%;*HilzVvZSx(mt&rG8 z)p^S?s?w}v5ZzFLRJPQHTN+;v2o@9XD;P$Qc&|T4#!Fsz=_q$Bnvsm{3P-voFL||? zZ_dOMM|SrsP_A7~T|thsyw4YUTIcp=O_JQswQB@~a>1fJB?POh*tvr@sm_lrMoc0b zCSWHS_n?Bkl<*odMq)*MZp{j@aSxBgIT$OOP|MXJtB^IYEBie73v(G_0x=JBu~%wc z;w=$Smx_fKrWkqA8XV5I*0=gm?OxuduEWf|1iGdvQxPi82tww-V}=C*3#mW@W)blBl-JS!q0U9qUco>5!yF* zE22v$)^i<)tzJW&evzBYsw8v}+Pj5aYb!KOZKUQRg2As6E9P!;*Zje)GbgC$6vM6j zXYEP5czX!||c6@Y{r?D+I)+d1z;c^_Nu2?Xqi#)%d=kt1lx0=&s=qV4I z&6KeZ&r6}xAtj}9pD1J5jR<)jJ1(X;O&IfUOn7y%VBVW&bZyl8>pdB;2aJql1bmKb9y2}Poj!@+r>y?{s%4_0^{q=hP4#QYj`k~ugU=^o4hWah1SqG(2MO6Ov>D9C`_Nby zW^}p5w*`zJx>1PN*JvLYUHPTMLa?wAc8h2Dux1p?tP9ZpS$q?6nfuzF_U4;G4WA~n z3LIms@pwmBdY*a@BPm5#As~fOPq}hu#VQ}AHW2hE4pC35Rk)p{1uU%*!Lvc%$tPqq zCf@r6Ic-kKQ5YKq^L@EKU4jB-)UNqSNqn!brfY0|YX8QBR2dUN+#D}Tt;7v?UcDb7 zw5y0~R=^D*e|D1pm&AX2wGgl2_~udd$!x<>H?l_l5OdEHx-J}s{wE2Y?0XcGQx>V+ zd}FpCR1O*VA4BY-=dY2Fm8zJXQj)f{c`>lHjMeepra2QU8kG3XDRQl5A1jTML}2R5 zko8fO-AY?X8t;aF)AsEee4u z9t?0Z{);x$D5$C*2#m zaAsg--j2Gw1h-V^o|L+MO6W2%jJqDaq0se(!#Vpd={y_0PShOGkE7 z3Y`_^ge)qBThq#r*d$igMWLU}@4Me7A;0je|Lkq7>^_x^y#LCTS#M76B}RHthvHNo zBp_1nj-N${E!ZAcKQzxb5MnF26X_fq@t3On1DJMtaLQlw3KNtJ`N2&db8%ljYU0IL z;2-ypRJi;_%dE~Bws2uEaokqEc44}e90WI z96mVbMSEXNQ)znm;lc3|VZ=2-zIwK+5`!0sZ%^S>6ht7D){$;Sam@}%VYQrpWb+=0 zMf&XKCo!>kjf1{Khf;wV?XCR#@D}9e1&&50}Y_%(E$T; z%`=b|RSmQvA@Yr2c;y2pq&ntrQje>k9La3t(fDCFm=A27+h@(CtO#zO zkLYV=ZE9tDe=oK+C&UD<;3$S4>sx?Y(p_JKeNma&i0Xz1PK1x%>lNdpbp7Jnz}Ld83Htt&$M(<3vmM20^l$b3kb!H?nQ}a8MmqAUc+OGRGb& zwPS}L>K6*gUwzsFr%Znw(E5LHQ&gKmcZ#OtJqAx;zui_`)vik49M3T>UuwG=%KYR# z&${Q+IOVN3JI%NI4BzGWG>ZH)pD7Wm~s18}f6hD%Ru{K(T5)`GoB+Ocz{w zx!EcDl}QP;n?^ag(S#o))_8aI7WZrC}StoDPGqO2$G3VlS}12mM-=NOQN z8_xwe2*!pMJ55SWj%C-m1)#0AF~ZIX&_g@)k!$8sYWg?UU?ObP{!(eZ33v+ZQT;_W z+pkXdBQJuWoS|`1NXw;@NDvS4%fP!FEI$Xra*x3kRNA=;h@^rqAi*63kfPeJgh`(q zBJBFusVuLL0ag(OWdus*tjrHQTE`j%A3&Aet;u^<-FbbWaRY$7!FK%G?5f2}L+ip_ z4!_-E*B!ciU2q+k(J>+t^EAud=(Fn1E-cBmP|$d?x{cs zu!^d%kf0KGHaz=@!&i<8{F{}ife8;#0E<-MKO2uaz^297V1lw{1`o*O;zW41ov6m2B(04vmOLnfm#4If#Uj2~olg*qV~dlp>CttSl9#o9%^5Xf}Jz zhf9I)t+XQRoG@`CHz-ZdgjNdqxf?+N=}?9kQaQ$hoUO(7O$ULmLvUJlNDjU*YNZ0- zb3&exw|?gMhV7k0veZmH!(lIzxdC0XsySU-Z_268uw!%qh-Tsm4*S-*ds!e7Mq;q)f6cT z1&)SV$I!SL@01n2>O~^<005nC?+bdUv5*=d98$0+K`H+KD=>}|n;>oS*Qc54H=;A) MW;UiZe|p~iAB@uTmjD0& literal 0 HcmV?d00001