From 5b660dc22fb77eefdde38e16e8e11c9a197ea04f Mon Sep 17 00:00:00 2001 From: Usn Zorro <> Date: Mon, 25 Apr 2022 21:07:09 +0300 Subject: [PATCH] 1.0.2: USN contract released on the NEAR mainnet. --- .cargo/config | 2 + .github/workflows/release.yaml | 38 + .github/workflows/test.yaml | 28 + .gitignore | 5 + Cargo.toml | 40 + README.md | 230 ++++ images/buy.puml | 23 + images/buy.svg | 33 + images/sell.puml | 19 + images/sell.svg | 29 + package.json | 28 + scripts/build-docker.sh | 32 + scripts/demo.sh | 106 ++ scripts/deploy.sh | 20 + scripts/upgrade.js | 62 + src/event.rs | 23 + src/ft.rs | 233 ++++ src/lib.rs | 1305 +++++++++++++++++++++ src/oracle/mod.rs | 8 + src/oracle/oracle.rs | 111 ++ src/oracle/priceoracle.rs | 59 + src/owner.rs | 49 + src/storage.rs | 16 + src/treasury/balance_stable_pool.rs | 255 ++++ src/treasury/balance_treasury.rs | 524 +++++++++ src/treasury/cache.rs | 207 ++++ src/treasury/ft.rs | 21 + src/treasury/gas.rs | 16 + src/treasury/mod.rs | 11 + src/treasury/pool.rs | 111 ++ src/treasury/ref_finance.rs | 60 + src/treasury/transfer_stable_liquidity.rs | 254 ++++ src/treasury/treasury.rs | 22 + tests/price_oracle.wasm | Bin 0 -> 197498 bytes tests/ref_exchange.wasm | Bin 0 -> 561712 bytes tests/sandbox-setup.js | 281 +++++ tests/sandbox-start.js | 21 + tests/test_token.wasm | Bin 0 -> 178021 bytes tests/tests.js | 733 ++++++++++++ 39 files changed, 5015 insertions(+) create mode 100644 .cargo/config create mode 100644 .github/workflows/release.yaml create mode 100644 .github/workflows/test.yaml create mode 100644 .gitignore create mode 100644 Cargo.toml create mode 100644 README.md create mode 100644 images/buy.puml create mode 100644 images/buy.svg create mode 100644 images/sell.puml create mode 100644 images/sell.svg create mode 100644 package.json create mode 100755 scripts/build-docker.sh create mode 100755 scripts/demo.sh create mode 100755 scripts/deploy.sh create mode 100644 scripts/upgrade.js create mode 100644 src/event.rs create mode 100644 src/ft.rs create mode 100644 src/lib.rs create mode 100644 src/oracle/mod.rs create mode 100644 src/oracle/oracle.rs create mode 100644 src/oracle/priceoracle.rs create mode 100644 src/owner.rs create mode 100644 src/storage.rs create mode 100644 src/treasury/balance_stable_pool.rs create mode 100644 src/treasury/balance_treasury.rs create mode 100644 src/treasury/cache.rs create mode 100644 src/treasury/ft.rs create mode 100644 src/treasury/gas.rs create mode 100644 src/treasury/mod.rs create mode 100644 src/treasury/pool.rs create mode 100644 src/treasury/ref_finance.rs create mode 100644 src/treasury/transfer_stable_liquidity.rs create mode 100644 src/treasury/treasury.rs create mode 100755 tests/price_oracle.wasm create mode 100755 tests/ref_exchange.wasm create mode 100644 tests/sandbox-setup.js create mode 100644 tests/sandbox-start.js create mode 100755 tests/test_token.wasm create mode 100644 tests/tests.js diff --git a/.cargo/config b/.cargo/config new file mode 100644 index 0000000..58910a4 --- /dev/null +++ b/.cargo/config @@ -0,0 +1,2 @@ +[build] +rustflags = ["-C", "link-args=-s"] diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml new file mode 100644 index 0000000..9a0ed31 --- /dev/null +++ b/.github/workflows/release.yaml @@ -0,0 +1,38 @@ +name: Publish release + +on: + create: + tags: + - v* + +jobs: + test: + uses: ./.github/workflows/test.yaml + + release: + needs: test + + runs-on: ubuntu-latest + + container: + image: nearprotocol/contract-builder + options: --cap-add=SYS_PTRACE --security-opt seccomp=unconfined + env: + RUSTFLAGS: -C link-arg=-s + + steps: + - uses: actions/checkout@v2 + - name: Build + run: | + rustup toolchain install stable + rustup default stable + rustup target add wasm32-unknown-unknown + cargo build --target wasm32-unknown-unknown --profile testnet --features testnet + cargo build --target wasm32-unknown-unknown --profile mainnet --features mainnet + mv target/wasm32-unknown-unknown/mainnet/usn.wasm target/usn.mainnet.wasm + mv target/wasm32-unknown-unknown/testnet/usn.wasm target/usn.testnet.wasm + - name: Publish + uses: ncipollo/release-action@v1 + with: + artifacts: "target/usn.*.wasm" + token: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml new file mode 100644 index 0000000..590b503 --- /dev/null +++ b/.github/workflows/test.yaml @@ -0,0 +1,28 @@ +name: Run tests + +on: + workflow_call: + + push: + branches: + - main + + pull_request: + branches: + - main + +jobs: + test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - name: Run Rustfmt + run: cargo fmt -- --check + - name: Run unit tests + run: cargo test --verbose + - name: Install NPM dependencies + run: npm install + - name: Build USN + run: npm run build + - name: Run integration tests on sandbox + run: npm run test diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..c3494c8 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +target/* +node_modules/* +package-lock.json +*.lock +*.iml diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..94ba522 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,40 @@ +[package] +edition = "2018" +name = "usn" +version = "1.0.2" + +[lib] +crate-type = ["cdylib", "rlib"] + +[dependencies] +near-contract-standards = "=4.0.0-pre.7" +near-sdk = { version = "=4.0.0-pre.7", features = ["unstable"] } +uint = { version = "=0.9.0", default-features = false } +partial-min-max = "0.4.0" +easy-ml = "1.8.1" + +[profile.release] +codegen-units = 1 +debug = false +lto = true +opt-level = "s" +overflow-checks = true +panic = "abort" + +[profile.sandbox] +inherits = "release" + +[profile.testnet] +inherits = "release" + +[profile.mainnet] +inherits = "release" + +[features] +# Enables testnet configuration if expicitly stated. +# It makes the USN contract use a testnet oracle. +testnet = [] + +# Enables mainnet configuration if expicitly stated. +# It makes the USN contract use a main oracle. +mainnet = [] diff --git a/README.md b/README.md new file mode 100644 index 0000000..0e2bfe6 --- /dev/null +++ b/README.md @@ -0,0 +1,230 @@ +[![USN](https://github.com/binary-star-near/usn/actions/workflows/test.yaml/badge.svg?event=push)](https://github.com/binary-star-near/usn) + +# USN + +USN is a NEAR-native USD stable coin. + +The contract implements fungible token API according to the following standards: + +1. [NEP-141](https://nomicon.io/Standards/FungibleToken/Core) (ERC-20 fashioned) +2. [NEP-148](https://nomicon.io/Standards/FungibleToken/Metadata) +3. [Fungible Token Event](https://nomicon.io/Standards/FungibleToken/Event) + +The specific part of the USN contract is `buy`/`sell` methods of NEAR/USD exchange with rates taken from the oracle ([priceoracle](https://github.com/NearDeFi/price-oracle/)). + +# Contract Address + +| Mainnet | Testnet | +| ------- | ------------ | +| usn | usdn.testnet | + +# How It Works + +## Buy USN for NEAR + +_Method:_ `buy` + +Buy USN + +## Sell USN for NEAR with `sell` API + +_Method:_ `sell` + +Sell USN + +## Slippage + +Methods `buy` and `sell` requires the _expected_ exchange rate to avoid slippage. If the price suddenly changes (slips) out of the expected deviation the USN contract aborts the transaction. + +# Build + +First, install prerequisites: + +```bash +npm install +``` + +Then, build. + +For local sandbox: + +```bash +npm run build +``` + +For testnet: + +```bash +npm run build:testnet +``` + +For mainnet: + +```bash +npm run build:mainnet +``` + +**WARNING**: There is a difference in each target. The crucial difference is that they communicate with different oracle addresses: + +- Mainnet: `priceoracle.near` +- Testnet: `priceoracle.testnet` +- Sandbox: `priceoracle.test.near` + +And all these oracle contracts report prices with different asset names. + +# Test + +## Run unit tests + +```bash +cargo test +``` + +## Run integration tests + +```bash +npm run build +npm run deploy +npm run test +``` + +## Manual testing on the Testnet + +Build + +```bash +npm run build:testnet +``` + +Deploy + +```bash +near deploy --force --wasmFile target/wasm32-unknown-unknown/testnet/usn.wasm --accountId=usdn.testnet --masterAccount=usdn.testnet +``` + +Init once + +```bash +near call usdn.testnet new --args '{"owner_id": "usdn.testnet"}' --accountId=usdn.testnet +``` + +Add a guardian + +```bash +near call usdn.testnet extend_guardians --accountId usdn.testnet --args '{"guardians": ["alice.testnet"]}' +``` + +Buy and sell + +```bash +# Send NEAR, buy USN. +near call usdn.testnet buy --accountId alice.testnet --amount 1 --gas 50000000000000 + +# Check USN balance. +near call usdn.testnet ft_balance_of --accountId alice.testnet --args '{"account_id": "alice.testnet"}' + +# Sell USN, receive NEAR. +near call usdn.testnet sell --accountId alice.testnet --args '{"amount": "118800"}' --amount 0.000000000000000000000001 --gas 50000000000000 + +# Buy USN with slippage control + near call usdn.testnet buy --args '{"expected": {"multiplier": "111439", "slippage": "10", "decimals": "28" }}' --accountId alice.testnet --amount 1 --gas 50000000000000 + +# Buy USN and transfer to someone. +near call usdn.testnet buy --args '{"to": "bob.testnet"}' --accountId alice.testnet --amount 1 --gas 50000000000000 +``` + +# DAO + +## Upgrade the contract via Upgrade Proposal + +1. Download `usn.mainnet.wasm` from https://github.com/binary-star-near/usn/releases +2. Create an upgrade proposal: + ```bash + sputnikdao proposal upgrade usn.mainnet.wasm usn --daoAcc usn --accountId alice.near --network mainnet + ``` + +# API + +## Buy/sell USN + +Send NEAR, receive USN. + +```rust +pub fn buy(&mut self, expected: Option, to: Option); +``` + +Send USN, receive NEAR. + +```rust +pub fn sell(&mut self, amount: U128, expected: Option) -> Promise; +``` + +## View methods + +```rust +pub fn contract_status(&self) -> ContractStatus; +pub fn name(&self) -> String; +pub fn symbol(&self) -> String; +pub fn decimals(&self) -> u8; +pub fn spread(&self, amount: Option) -> U128; +pub fn version(&self) -> String; +pub fn blacklist_status(&self, account_id: &AccountId) -> BlackListStatus; +pub fn owner(&self); +``` + +## NEP-141 (ERC-20) + +```rust +pub fn ft_transfer(&mut self, receiver_id: AccountId, amount: U128, memo: Option); +pub fn ft_transfer_call( + &mut self, + receiver_id: AccountId, + amount: U128, + memo: Option, + msg: String, + ) -> PromiseOrValue; +pub fn ft_total_supply(&self) -> U128; +pub fn ft_balance_of(&self, account_id: AccountId) -> U128; +pub fn ft_metadata(&self) -> FungibleTokenMetadata; +``` + +## NEP-145: partial storage API + +Always returns 125 milliNEAR indicating that user doesn't need to be registered +with `storage_deposit`. + +```rust +pub fn storage_balance_of(&self, account_id: AccountId) -> Option; +``` + +## Constructor + +```rust +pub fn new(owner_id: AccountId) -> Self; +``` + +## Private setters + +For owner only. + +```rust +pub fn upgrade_name_symbol(&mut self, name: String, symbol: String); +pub fn upgrade_icon(&mut self, data: String); +pub fn add_to_blacklist(&mut self, account_id: &AccountId); +pub fn remove_from_blacklist(&mut self, account_id: &AccountId); +pub fn destroy_black_funds(&mut self, account_id: &AccountId); +pub fn pause(&mut self); +pub fn resume(&mut self); +pub fn set_fixed_spread(&mut self, spread: U128) { +pub fn set_adaptive_spread(&mut self, params: Option); +pub fn set_owner(&mut self, owner_id: AccountId); +pub fn extend_guardians(&mut self, guardians: Vec); +pub fn remove_guardians(&mut self, guardians: Vec); +``` + +## Upgradability + +```rust +pub fn upgrade(); +pub fn migrate() -> Self; +``` diff --git a/images/buy.puml b/images/buy.puml new file mode 100644 index 0000000..27f85e5 --- /dev/null +++ b/images/buy.puml @@ -0,0 +1,23 @@ +@startuml + +title Buy USN + +alice -> usn: send NEAR\n+ expected rate\n+ slippage\n+ transfer to + +usn -> priceoracle: ""get_price_data"" +activate priceoracle +usn <- priceoracle: NEAR/USDT rate +deactivate priceoracle +usn -> usn: verify timestamp + +alt if expected rate and slippage is passed +usn -> usn: assert slippage +end + +usn -> usn: mint USN + +alice <-- usn: USN amount +alt If "transfer to" is defined +bob <-- usn: USN amount +end +@enduml diff --git a/images/buy.svg b/images/buy.svg new file mode 100644 index 0000000..2e5a18f --- /dev/null +++ b/images/buy.svg @@ -0,0 +1,33 @@ +Buy USNalicealiceusnusnpriceoraclepriceoraclebobbobsend NEAR+ expected rate+ slippage+ transfer toget_price_dataNEAR/USDT rateverify timestampalt[if expected rate and slippage is passed]assert slippagemint USNUSN amountalt[If "transfer to" is defined]USN amount \ No newline at end of file diff --git a/images/sell.puml b/images/sell.puml new file mode 100644 index 0000000..70b80f1 --- /dev/null +++ b/images/sell.puml @@ -0,0 +1,19 @@ +@startuml + +title Sell USN + +alice -> usn: USN amount\n+ expected rate\n+ slippage + +usn -> priceoracle: ""get_price_data"" +activate priceoracle +usn <- priceoracle: NEAR/USDT rate +deactivate priceoracle +usn -> usn: verify timestamp + +alt If expected rate and slippage is passed +usn -> usn: assert slippage +end + +usn -> usn: burn USN +alice <-- usn: send NEAR +@enduml \ No newline at end of file diff --git a/images/sell.svg b/images/sell.svg new file mode 100644 index 0000000..9cd567b --- /dev/null +++ b/images/sell.svg @@ -0,0 +1,29 @@ +Sell USNalicealiceusnusnpriceoraclepriceoracleUSN amount+ expected rate+ slippageget_price_dataNEAR/USDT rateverify timestampalt[If expected rate and slippage is passed]assert slippageburn USNsend NEAR \ No newline at end of file diff --git a/package.json b/package.json new file mode 100644 index 0000000..f7d1fe8 --- /dev/null +++ b/package.json @@ -0,0 +1,28 @@ +{ + "name": "usn", + "scripts": { + "prebuild": "rustup target add wasm32-unknown-unknown", + "build": "cargo build --target wasm32-unknown-unknown --profile sandbox", + "build:sandbox": "npm run build", + "build:testnet": "cargo build --target wasm32-unknown-unknown --profile testnet --features testnet", + "build:mainnet": "cargo build --target wasm32-unknown-unknown --profile mainnet --features mainnet", + "deploy": "./scripts/deploy.sh", + "demo": "./scripts/demo.sh", + "upgrade": "node scripts/upgrade.js", + "upgrade:sandbox": "npm run upgrade", + "upgrade:testnet": "NEAR_ENV=testnet npm run upgrade", + "sandbox:init": "rm -rf /tmp/near-usn-sandbox && near-sandbox --home /tmp/near-usn-sandbox init", + "sandbox": "near-sandbox --home /tmp/near-usn-sandbox run", + "sandbox:test": "rm -rf /tmp/near-usn-test-sandbox && near-sandbox --home /tmp/near-usn-test-sandbox init && near-sandbox --home /tmp/near-usn-test-sandbox run", + "pretest": "npm run build", + "test": "mocha --require tests/sandbox-start.js --require tests/sandbox-setup.js tests" + }, + "devDependencies": { + "bn": "^1.0.5", + "is-reachable": "^5.1.1", + "mocha": "^9.1.3", + "near-api-js": "^0.44.2", + "near-sandbox": "^0.0.9", + "tree-kill": "^1.2.2" + } +} \ No newline at end of file diff --git a/scripts/build-docker.sh b/scripts/build-docker.sh new file mode 100755 index 0000000..b3aea2a --- /dev/null +++ b/scripts/build-docker.sh @@ -0,0 +1,32 @@ +#!/usr/bin/env bash + +# Exit script as soon as a command fails. +set -e + +DIR="$( cd "$( dirname "${BASH_SOURCE[0]}")/.." >/dev/null 2>&1 && pwd )" + +NAME="build-usn" + +if docker ps -a --format '{{.Names}}' | grep -Eq "^${NAME}\$"; then + echo "Container exists" +else +docker create \ + --mount type=bind,source=$DIR/..,target=/host \ + --cap-add=SYS_PTRACE --security-opt seccomp=unconfined \ + --name=$NAME \ + -w /host/usn \ + -e RUSTFLAGS='-C link-arg=-s' \ + -it \ + nearprotocol/contract-builder \ + /bin/bash +fi + +docker start $NAME +docker exec -it $NAME /bin/bash -c "\ +rustup toolchain install stable; \ +rustup default stable; \ +rustup target add wasm32-unknown-unknown; \ +cargo build --target wasm32-unknown-unknown --profile mainnet --features mainnet" + +mkdir -p res +cp $DIR/target/wasm32-unknown-unknown/mainnet/usn.wasm $DIR/res/usn.wasm \ No newline at end of file diff --git a/scripts/demo.sh b/scripts/demo.sh new file mode 100755 index 0000000..b13479f --- /dev/null +++ b/scripts/demo.sh @@ -0,0 +1,106 @@ +#!/bin/bash + +ENV="sandbox" +RED="\033[0;31m" +NC='\033[0m' +NEAR_PRICE="113400" + +# Amount of tokens that have to be issued (total supply: 1000 tokens) +TOTAL_SUPPLY=1000000000000000000000000000 + +if [ $ENV == "testnet" ]; then + SANDBOX="" + + near dev-deploy --wasm-file target/wasm32-unknown-unknown/testnet/usn.wasm --force + + ID=$(cat neardev/dev-account) + # ID=(cat neardev/dev-account) + + near call $ID new '{"owner_id": "'${ID}'"}' --account-id $ID + +else + SANDBOX=" --networkId sandbox --nodeUrl http://0.0.0.0:3030 --keyPath /tmp/near-usn-sandbox/validator_key.json" + ID=test.near + + near deploy --wasm-file target/wasm32-unknown-unknown/sandbox/usn.wasm \ + --initFunction new \ + --initArgs '{"owner_id": "'${ID}'"}' \ + --account-id $ID \ + --master-account $ID \ + --force \ + $SANDBOX +fi + +echo -e "${NC}" +near create-account bob.$ID --masterAccount $ID --initialBalance 1 $SANDBOX +near call $ID storage_deposit '' --accountId bob.$ID --amount 0.00125 $SANDBOX + +echo -e "\n${RED}BOB BUYS SOME TOKENS:${NC}" +near call $ID extend_guardians --accountId $ID --args '{"guardians": ["'bob.$ID'"]}' $SANDBOX +near call $ID buy '{"expected": {"multiplier": "'$NEAR_PRICE'", "decimals": 28, "slippage": "10000"}}' --accountId bob.$ID --amount 0.1 $SANDBOX --gas 200000000000000 +near view $ID ft_balance_of --args '{"account_id": "'bob.$ID'"}' $SANDBOX + +near create-account alice.$ID --masterAccount $ID --initialBalance 1 $SANDBOX + +echo -e "\n${RED}ALICE BUYS SOME TOKENS WITH AUTO-REGISTRATION:${NC}" +near call $ID buy --accountId alice.$ID --amount 0.1 $SANDBOX --gas 200000000000000 + +echo -e "\n${RED}BOB BUYS SOME TOKENS WITH WRONG SLIPPAGE:${NC}" + +BALANCE1=$(near state "'bob.$ID'" | sed -n "s/.*formattedAmount: '\([^\\]*\).*'/\1/p") +echo "'$BALANCE1'" + +near call $ID buy '{"expected": {"multiplier": "'$NEAR_PRICE'", "decimals": 28, "slippage": "1"}}' --accountId bob.$ID --amount 0.1 $SANDBOX --gas 200000000000000 + +BALANCE2=$(near state "'bob.$ID'" | sed -n "s/.*formattedAmount: '\([^\\]*\).*'/\1/p") +echo "'$BALANCE2'" +if [ "'$BALANCE1'" != "'$BALANCE2'" ]; then + echo "Balance updated" +fi + +near view $ID ft_balance_of --args '{"account_id": "'bob.$ID'"}' $SANDBOX + +echo -e "\n${RED}BOB SELLS SOME TOKENS:${NC}" + +near view $ID ft_balance_of --args '{"account_id": "'bob.$ID'"}' $SANDBOX +near state "'bob.$ID'" | sed -n "s/.*formattedAmount: '\([^\\]*\).*'/\1/p" + +near call $ID sell '{"amount": "1000003499999999999", "expected": {"multiplier": "'$NEAR_PRICE'", "decimals": 28, "slippage": "10000"}}' --accountId bob.$ID --depositYocto 1 $SANDBOX --gas 200000000000000 + +near view $ID ft_balance_of --args '{"account_id": "'bob.$ID'"}' $SANDBOX + +echo -e "\n${RED}TOTAL SUPPLY:${NC}" +near view $ID ft_total_supply --args '{}' $SANDBOX + +echo -e "\n${RED}TRANSFER:${NC}" +near call $ID ft_transfer --accountId bob.$ID --args '{"receiver_id": "'$ID'", "amount": "1"}' --amount 0.000000000000000000000001 $SANDBOX + +echo -e "\n${RED}IS BOB IN THE BLACKLIST:${NC}" +near call $ID blacklist_status --accountId $ID --args '{"account_id": "'bob.$ID'"}' $SANDBOX + +echo -e "\n${RED}BOB TRYING HIMSELF ADD TO THE BLACKLIST:${NC}" +near call $ID add_to_blacklist --accountId bob.$ID --args '{"account_id": "'bob.$ID'"}' $SANDBOX +near call $ID blacklist_status --accountId $ID --args '{"account_id": "'bob.$ID'"}' $SANDBOX + +echo -e "\n${RED}TEST.NEAR TRYING ADD BOB TO THE BLACKLIST:${NC}" +near call $ID add_to_blacklist --accountId $ID --args '{"account_id": "'bob.$ID'"}' $SANDBOX +near call $ID blacklist_status --accountId $ID --args '{"account_id": "'bob.$ID'"}' $SANDBOX + +echo -e "\n${RED}BURN BANNED BOB FUNDS:${NC}" +near call $ID destroy_black_funds --accountId $ID --args '{"account_id": "'bob.$ID'"}' $SANDBOX +near view $ID ft_balance_of --args '{"account_id": "'bob.$ID'"}' $SANDBOX + +echo -e "\n${RED}UNBAN BOB:${NC}" +near call $ID remove_from_blacklist --accountId $ID --args '{"account_id": "'bob.$ID'"}' $SANDBOX +near call $ID blacklist_status --accountId $ID --args '{"account_id": "'bob.$ID'"}' $SANDBOX + +echo -e "\n${RED}MAINTENANCE ON:${NC}" +near call $ID pause --accountId $ID --args '{}' $SANDBOX +near call $ID contract_status --accountId $ID --args '{}' $SANDBOX + +echo -e "\n${RED}TRANSFER:${NC}" +near call $ID ft_transfer --accountId $ID --args '{"receiver_id": "'bob.$ID'", "amount": "1"}' --amount 0.000000000000000000000001 $SANDBOX + +echo -e "\n${RED}MAINTENANCE OFF:${NC}" +near call $ID resume --accountId $ID --args '{}' $SANDBOX +near call $ID contract_status --accountId $ID --args '{}' $SANDBOX diff --git a/scripts/deploy.sh b/scripts/deploy.sh new file mode 100755 index 0000000..02ef3d1 --- /dev/null +++ b/scripts/deploy.sh @@ -0,0 +1,20 @@ +# Sandbox account +ID=test.near + +# Amount of tokens that have to be issued (total supply: 1000 tokens) +TOTAL_SUPPLY=1000000000000000000000000000 + +near deploy --wasm-file target/wasm32-unknown-unknown/sandbox/usn.wasm \ + --account-id $ID \ + --master-account $ID \ + --networkId sandbox \ + --nodeUrl http://0.0.0.0:3030 \ + --keyPath /tmp/near-usn-sandbox/validator_key.json \ + --force + +near call $ID new \ + --account-id $ID \ + --args '{"owner_id": "'$ID'"}' \ + --networkId sandbox \ + --nodeUrl http://0.0.0.0:3030 \ + --keyPath /tmp/near-usn-sandbox/validator_key.json diff --git a/scripts/upgrade.js b/scripts/upgrade.js new file mode 100644 index 0000000..487f5cd --- /dev/null +++ b/scripts/upgrade.js @@ -0,0 +1,62 @@ +'use strict'; +const nearAPI = require('near-api-js'); +const fs = require('fs').promises; +const assert = require('assert').strict; + +const configSandbox = { + networkId: 'sandbox', + nodeUrl: 'http://0.0.0.0:3030', + keyPath: '/tmp/near-usn-sandbox/validator_key.json', + contractPath: './target/wasm32-unknown-unknown/sandbox/usn.wasm', + accountId: 'test.near', + contractId: 'test.near', +}; + +const configTestnet = { + networkId: 'testnet', + nodeUrl: 'https://rpc.testnet.near.org', + keyPath: require('os').homedir() + '/.near-credentials/testnet/usdn.testnet.json', + contractPath: './target/wasm32-unknown-unknown/testnet/usn.wasm', + accountId: 'usdn.testnet', + contractId: 'usdn.testnet', +}; + +const config = process.env.NEAR_ENV == 'testnet' ? configTestnet : configSandbox; + +const methods = { + viewMethods: ['version'], +}; + +(async function () { + const keyFile = require(config.keyPath); + const privKey = nearAPI.utils.KeyPair.fromString( + keyFile.secret_key || keyFile.private_key + ); + + const keyStore = new nearAPI.keyStores.InMemoryKeyStore(); + keyStore.setKey(config.networkId, config.accountId, privKey); + + const near = await nearAPI.connect({ + deps: { + keyStore, + }, + networkId: config.networkId, + nodeUrl: config.nodeUrl, + }); + + const wasm = await fs.readFile(config.contractPath); + const account = new nearAPI.Account(near.connection, config.accountId); + + // Update the contract. + await account.signAndSendTransaction({ + receiverId: config.contractId, + actions: [ + nearAPI.transactions.functionCall('upgrade', wasm, 100000000000000, '0'), + ], + }); + + // Check that the contract has been upgraded. + // Change the `version` method returning 'UPGRADED:VERSION' to test this. + const contract = new nearAPI.Contract(account, config.contractId, methods); + assert.equal(await contract.version(), 'UPGRADED:VERSION'); +})(); diff --git a/src/event.rs b/src/event.rs new file mode 100644 index 0000000..97f076c --- /dev/null +++ b/src/event.rs @@ -0,0 +1,23 @@ +pub mod emit { + use near_contract_standards::fungible_token::events::{FtBurn, FtMint}; + + use crate::*; + + pub fn ft_mint(owner_id: &AccountId, amount: Balance, memo: Option<&str>) { + (FtMint { + owner_id: owner_id, + amount: &amount.into(), + memo: memo, + }) + .emit(); + } + + pub fn ft_burn(owner_id: &AccountId, amount: Balance, memo: Option<&str>) { + (FtBurn { + owner_id: owner_id, + amount: &amount.into(), + memo: memo, + }) + .emit(); + } +} diff --git a/src/ft.rs b/src/ft.rs new file mode 100644 index 0000000..1ce22c6 --- /dev/null +++ b/src/ft.rs @@ -0,0 +1,233 @@ +use crate::*; +use near_contract_standards::fungible_token::core_impl::ext_fungible_token_receiver; +use near_contract_standards::fungible_token::events::FtTransfer; +use near_sdk::{log, require, IntoStorageKey, PromiseResult, StorageUsage}; + +const GAS_FOR_RESOLVE_TRANSFER: Gas = Gas(5_000_000_000_000); +const GAS_FOR_FT_TRANSFER_CALL: Gas = Gas(25_000_000_000_000 + GAS_FOR_RESOLVE_TRANSFER.0); + +const NO_DEPOSIT: Balance = 0; + +#[ext_contract(ext_ft_self)] +trait FungibleTokenResolver { + fn ft_resolve_transfer( + &mut self, + sender_id: AccountId, + receiver_id: AccountId, + amount: U128, + ) -> U128; +} + +/// Implementation of a FungibleToken standard. +/// Allows to include NEP-141 compatible token to any contract. +/// There are next traits that any contract may implement: +/// - FungibleTokenCore -- interface with ft_transfer methods. FungibleToken provides methods for it. +/// - FungibleTokenMetaData -- return metadata for the token in NEP-148, up to contract to implement. +/// +/// For example usage, see examples/fungible-token/src/lib.rs. +#[derive(BorshDeserialize, BorshSerialize)] +pub struct FungibleTokenFreeStorage { + /// AccountID -> Account balance. + pub accounts: LookupMap, + + /// Total supply of the all token. + pub total_supply: Balance, + + /// DEPRECATED. Kept to match state without upgradability. + /// Previously the maximum storage size of one account. + pub _unused: StorageUsage, +} + +impl FungibleTokenFreeStorage { + pub fn new(prefix: S) -> Self + where + S: IntoStorageKey, + { + Self { + accounts: LookupMap::new(prefix), + total_supply: 0, + _unused: 0, + } + } + + pub fn internal_unwrap_balance_of(&self, account_id: &AccountId) -> Balance { + self.accounts.get(account_id).unwrap_or(0) + } + + pub fn internal_save_balance(&mut self, account_id: &AccountId, balance: Balance) { + if balance > 0 { + self.accounts.insert(account_id, &balance); + } else { + self.accounts.remove(account_id); + } + } + + pub fn internal_deposit(&mut self, account_id: &AccountId, amount: Balance) { + let balance = self.internal_unwrap_balance_of(account_id); + if let Some(new_balance) = balance.checked_add(amount) { + self.internal_save_balance(account_id, new_balance); + self.total_supply = self + .total_supply + .checked_add(amount) + .unwrap_or_else(|| env::panic_str("Total supply overflow")); + } else { + env::panic_str("Balance overflow"); + } + } + + pub fn internal_withdraw(&mut self, account_id: &AccountId, amount: Balance) { + let balance = self.internal_unwrap_balance_of(account_id); + if let Some(new_balance) = balance.checked_sub(amount) { + self.internal_save_balance(account_id, new_balance); + self.total_supply = self + .total_supply + .checked_sub(amount) + .unwrap_or_else(|| env::panic_str("Total supply overflow")); + } else { + env::panic_str("The account doesn't have enough balance"); + } + } + + pub fn internal_transfer( + &mut self, + sender_id: &AccountId, + receiver_id: &AccountId, + amount: Balance, + memo: Option, + ) { + require!( + sender_id != receiver_id, + "Sender and receiver should be different" + ); + require!(amount > 0, "The amount should be a positive number"); + self.internal_withdraw(sender_id, amount); + self.internal_deposit(receiver_id, amount); + FtTransfer { + old_owner_id: sender_id, + new_owner_id: receiver_id, + amount: &U128(amount), + memo: memo.as_deref(), + } + .emit(); + } + + pub fn internal_transfer_call( + &mut self, + sender_id: &AccountId, + receiver_id: &AccountId, + amount: Balance, + gas: Gas, + memo: Option, + msg: String, + ) -> Promise { + require!(gas > GAS_FOR_FT_TRANSFER_CALL, "More gas is required"); + self.internal_transfer(sender_id, receiver_id, amount, memo); + // Initiating receiver's call and the callback + ext_fungible_token_receiver::ft_on_transfer( + sender_id.clone(), + amount.into(), + msg, + receiver_id.clone(), + NO_DEPOSIT, + gas - GAS_FOR_FT_TRANSFER_CALL, + ) + .then(ext_ft_self::ft_resolve_transfer( + sender_id.clone(), + receiver_id.clone(), + amount.into(), + env::current_account_id(), + NO_DEPOSIT, + GAS_FOR_RESOLVE_TRANSFER, + )) + } +} + +impl FungibleTokenCore for FungibleTokenFreeStorage { + fn ft_transfer(&mut self, receiver_id: AccountId, amount: U128, memo: Option) { + assert_one_yocto(); + let sender_id = env::predecessor_account_id(); + let amount: Balance = amount.into(); + self.internal_transfer(&sender_id, &receiver_id, amount, memo); + } + + fn ft_transfer_call( + &mut self, + receiver_id: AccountId, + amount: U128, + memo: Option, + msg: String, + ) -> PromiseOrValue { + assert_one_yocto(); + let sender_id = env::predecessor_account_id(); + let gas = env::prepaid_gas(); + self.internal_transfer_call(&sender_id, &receiver_id, amount.into(), gas, memo, msg) + .into() + } + + fn ft_total_supply(&self) -> U128 { + self.total_supply.into() + } + + fn ft_balance_of(&self, account_id: AccountId) -> U128 { + self.accounts.get(&account_id).unwrap_or(0).into() + } +} + +impl FungibleTokenFreeStorage { + /// Internal method that returns the amount of burned tokens in a corner case when the sender + /// has deleted (unregistered) their account while the `ft_transfer_call` was still in flight. + /// Returns (Used token amount, Burned token amount) + pub fn internal_ft_resolve_transfer( + &mut self, + sender_id: &AccountId, + receiver_id: AccountId, + amount: U128, + ) -> (u128, u128) { + let amount: Balance = amount.into(); + + // Get the unused amount from the `ft_on_transfer` call result. + let unused_amount = match env::promise_result(0) { + PromiseResult::NotReady => env::abort(), + PromiseResult::Successful(value) => { + if let Ok(unused_amount) = near_sdk::serde_json::from_slice::(&value) { + std::cmp::min(amount, unused_amount.0) + } else { + amount + } + } + PromiseResult::Failed => amount, + }; + + if unused_amount > 0 { + let receiver_balance = self.internal_unwrap_balance_of(&receiver_id); + if receiver_balance > 0 { + let refund_amount = std::cmp::min(receiver_balance, unused_amount); + self.internal_save_balance(&receiver_id, receiver_balance - refund_amount); + + let sender_balance = self.internal_unwrap_balance_of(&sender_id); + self.internal_save_balance(&sender_id, sender_balance + refund_amount); + log!( + "Refund {} from {} to {}", + refund_amount, + receiver_id, + sender_id + ); + return (amount - refund_amount, 0); + } + } + (amount, 0) + } +} + +impl FungibleTokenResolver for FungibleTokenFreeStorage { + fn ft_resolve_transfer( + &mut self, + sender_id: AccountId, + receiver_id: AccountId, + amount: U128, + ) -> U128 { + self.internal_ft_resolve_transfer(&sender_id, receiver_id, amount) + .0 + .into() + } +} diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..d9b2d76 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,1305 @@ +#![deny(warnings)] +mod event; +mod ft; +mod oracle; +mod owner; +mod storage; +mod treasury; + +use near_contract_standards::fungible_token::core::FungibleTokenCore; +use near_contract_standards::fungible_token::metadata::{ + FungibleTokenMetadata, FungibleTokenMetadataProvider, FT_METADATA_SPEC, +}; +use near_contract_standards::fungible_token::resolver::FungibleTokenResolver; +use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize}; +use near_sdk::collections::{LazyOption, LookupMap, UnorderedSet}; +use near_sdk::json_types::{U128, U64}; +use near_sdk::serde::{Deserialize, Serialize}; +use near_sdk::{ + assert_one_yocto, env, ext_contract, is_promise_success, near_bindgen, sys, AccountId, Balance, + BorshStorageKey, Gas, PanicOnDefault, Promise, PromiseOrValue, +}; + +use std::fmt::Debug; + +use crate::ft::FungibleTokenFreeStorage; +use oracle::{ExchangeRate, Oracle, PriceData}; +use treasury::TreasuryData; + +uint::construct_uint!( + pub struct U256(4); +); + +const NO_DEPOSIT: Balance = 0; +const USN_DECIMALS: u8 = 18; +const GAS_FOR_REFUND_PROMISE: Gas = Gas(5_000_000_000_000); +const GAS_FOR_BUY_PROMISE: Gas = Gas(10_000_000_000_000); +const GAS_FOR_SELL_PROMISE: Gas = Gas(15_000_000_000_000); +const GAS_FOR_RETURN_VALUE_PROMISE: Gas = Gas(5_000_000_000_000); + +const MAX_SPREAD: Balance = 50_000; // 0.05 = 5% +const SPREAD_DECIMAL: u8 = 6; +const SPREAD_MAX_SCALER: f64 = 0.4; + +#[derive(BorshStorageKey, BorshSerialize)] +enum StorageKey { + Guardians, + Token, + TokenMetadata, + Blacklist, + TreasuryData, +} + +#[derive(BorshDeserialize, BorshSerialize, Clone, Eq, PartialEq, Debug, Serialize, Deserialize)] +#[serde(crate = "near_sdk::serde")] +pub enum BlackListStatus { + // An address might be using + Allowable, + // All acts with an address have to be banned + Banned, +} + +#[derive(BorshDeserialize, BorshSerialize, Clone, Eq, PartialEq, Debug, Serialize, Deserialize)] +#[serde(crate = "near_sdk::serde")] +pub enum ContractStatus { + Working, + Paused, +} + +impl std::fmt::Display for ContractStatus { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + ContractStatus::Working => write!(f, "working"), + ContractStatus::Paused => write!(f, "paused"), + } + } +} + +#[derive(Serialize, Deserialize, Clone)] +#[serde(crate = "near_sdk::serde")] +pub struct ExpectedRate { + pub multiplier: U128, + pub slippage: U128, + pub decimals: u8, +} + +#[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize, Clone, Default)] +#[serde(crate = "near_sdk::serde")] +pub struct Commission { + usn: Balance, + near: Balance, +} + +#[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize, Clone)] +#[serde(crate = "near_sdk::serde")] +pub struct CommissionOutput { + usn: U128, + near: U128, +} + +impl From for CommissionOutput { + fn from(commission: Commission) -> Self { + Self { + usn: U128::from(commission.usn), + near: U128::from(commission.near), + } + } +} + +#[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)] +#[serde(crate = "near_sdk::serde")] +pub struct ExponentialSpreadParams { + pub min: f64, + pub max: f64, + pub scaler: f64, +} + +impl Default for ExponentialSpreadParams { + fn default() -> Self { + Self { + min: 0.001, + max: 0.005, + scaler: 0.0000075, + } + } +} + +#[derive(BorshDeserialize, BorshSerialize)] +pub enum Spread { + Fixed(Balance), + Exponential(ExponentialSpreadParams), +} + +#[near_bindgen] +#[derive(BorshDeserialize, BorshSerialize, PanicOnDefault)] +pub struct Contract { + owner_id: AccountId, + guardians: UnorderedSet, + token: FungibleTokenFreeStorage, + metadata: LazyOption, + black_list: LookupMap, + status: ContractStatus, + oracle: Oracle, + spread: Spread, + commission: Commission, + treasury: LazyOption, +} + +const DATA_IMAGE_SVG_NEAR_ICON: &str = + "data:image/svg+xml;charset=UTF-8,%3Csvg width='38' height='38' viewBox='0 0 38 38' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Crect width='38' height='38' rx='19' fill='black'/%3E%3Cpath d='M14.8388 10.6601C14.4203 10.1008 13.6748 9.86519 12.9933 10.0768C12.3119 10.2885 11.85 10.8991 11.85 11.5883V14.7648H8V17.9412H11.85V20.0589H8V23.2353H11.85V28H15.15V16.5108L23.1612 27.2165C23.5797 27.7758 24.3252 28.0114 25.0067 27.7997C25.6881 27.5881 26.15 26.9775 26.15 26.2882V23.2353H30V20.0589H26.15V17.9412H30V14.7648H26.15V10.0001H22.85V21.3658L14.8388 10.6601Z' fill='white'/%3E%3C/svg%3E"; + +#[ext_contract(ext_self)] +trait ContractCallback { + #[private] + fn buy_with_price_callback( + &mut self, + account: AccountId, + near: U128, + expected: Option, + #[callback] price: PriceData, + ) -> U128; + + #[private] + fn sell_with_price_callback( + &mut self, + account: AccountId, + tokens: U128, + expected: Option, + #[callback] price: PriceData, + ) -> Promise; + + #[private] + fn handle_refund(&mut self, account: AccountId, attached_deposit: U128); + + #[private] + fn return_value(&mut self, value: U128) -> U128; + + #[private] + fn handle_unregister(&mut self, account: AccountId); +} + +trait ContractCallback { + fn buy_with_price_callback( + &mut self, + account: AccountId, + near: U128, + expected: Option, + price: PriceData, + ) -> U128; + + fn sell_with_price_callback( + &mut self, + account: AccountId, + tokens: U128, + expected: Option, + price: PriceData, + ) -> Promise; + + fn handle_refund(&mut self, account: AccountId, attached_deposit: U128); + + fn return_value(&mut self, value: U128) -> U128; +} + +#[near_bindgen] +impl ContractCallback for Contract { + #[private] + fn buy_with_price_callback( + &mut self, + account: AccountId, + near: U128, + expected: Option, + #[callback] price: PriceData, + ) -> U128 { + let rate: ExchangeRate = price.into(); + + self.finish_buy(account, near.0, expected, rate).into() + } + + #[private] + fn sell_with_price_callback( + &mut self, + account: AccountId, + tokens: U128, + expected: Option, + #[callback] price: PriceData, + ) -> Promise { + let rate: ExchangeRate = price.into(); + + let deposit = self.finish_sell(account.clone(), tokens.0, expected, rate); + + Promise::new(account) + .transfer(deposit) + .then(ext_self::return_value( + deposit.into(), + env::current_account_id(), + 0, + GAS_FOR_RETURN_VALUE_PROMISE, + )) + } + + #[private] + fn handle_refund(&mut self, account: AccountId, attached_deposit: U128) { + if !is_promise_success() { + Promise::new(account) + .transfer(attached_deposit.0) + .as_return(); + } + } + + #[private] + fn return_value(&mut self, value: U128) -> U128 { + assert!(is_promise_success(), "Transfer has failed"); + // TODO: Remember lost value? Unlikely to happen, and only by user error. + value + } +} + +#[near_bindgen] +impl Contract { + /// Initializes the contract owned by the given `owner_id` with default metadata. + #[init] + pub fn new(owner_id: AccountId) -> Self { + let metadata = FungibleTokenMetadata { + spec: FT_METADATA_SPEC.to_string(), + name: "USN".to_string(), + symbol: "USN".to_string(), + icon: Some(DATA_IMAGE_SVG_NEAR_ICON.to_string()), + reference: None, + reference_hash: None, + decimals: USN_DECIMALS, + }; + + let mut this = Self { + owner_id: owner_id.clone(), + guardians: UnorderedSet::new(StorageKey::Guardians), + token: FungibleTokenFreeStorage::new(StorageKey::Token), + metadata: LazyOption::new(StorageKey::TokenMetadata, Some(&metadata)), + black_list: LookupMap::new(StorageKey::Blacklist), + status: ContractStatus::Working, + oracle: Oracle::default(), + spread: Spread::Exponential(ExponentialSpreadParams::default()), + commission: Commission::default(), + treasury: LazyOption::new(StorageKey::TreasuryData, Some(&TreasuryData::default())), + }; + + this.token.internal_deposit(&owner_id, NO_DEPOSIT); + this + } + + pub fn upgrade_name_symbol(&mut self, name: String, symbol: String) { + self.assert_owner(); + let metadata = self.metadata.take(); + if let Some(mut metadata) = metadata { + metadata.name = name; + metadata.symbol = symbol; + self.metadata.replace(&metadata); + } + } + + pub fn upgrade_icon(&mut self, data: String) { + self.assert_owner(); + let metadata = self.metadata.take(); + if let Some(mut metadata) = metadata { + metadata.icon = Some(data); + self.metadata.replace(&metadata); + } + } + + pub fn blacklist_status(&self, account_id: &AccountId) -> BlackListStatus { + return match self.black_list.get(account_id) { + Some(x) => x.clone(), + None => BlackListStatus::Allowable, + }; + } + + pub fn add_to_blacklist(&mut self, account_id: &AccountId) { + self.assert_owner(); + self.black_list.insert(account_id, &BlackListStatus::Banned); + } + + pub fn remove_from_blacklist(&mut self, account_id: &AccountId) { + self.assert_owner(); + self.black_list + .insert(account_id, &BlackListStatus::Allowable); + } + + pub fn destroy_black_funds(&mut self, account_id: &AccountId) { + self.assert_owner(); + assert_eq!(self.blacklist_status(&account_id), BlackListStatus::Banned); + let black_balance = self.ft_balance_of(account_id.clone()); + if black_balance.0 <= 0 { + env::panic_str("The account doesn't have enough balance"); + } + self.token.accounts.insert(account_id, &0u128); + self.token.total_supply = self + .token + .total_supply + .checked_sub(u128::from(black_balance)) + .expect("Failed to decrease total supply"); + } + + /// Pauses the contract. Only can be called by owner or guardians. + #[payable] + pub fn pause(&mut self) { + assert_one_yocto(); + // TODO: Should guardians be able to pause? + self.assert_owner_or_guardian(); + self.status = ContractStatus::Paused; + } + + /// Resumes the contract. Only can be called by owner. + pub fn resume(&mut self) { + self.assert_owner(); + self.status = ContractStatus::Working; + } + + /// Buys USN tokens for NEAR tokens. + /// Can make cross-contract call to an oracle. + /// Returns amount of purchased USN tokens. + /// NOTE: The method returns a promise, but SDK doesn't support clone on promise and we + /// want to return a promise in the middle. + #[payable] + pub fn buy(&mut self, expected: Option, to: Option) { + self.abort_if_pause(); + self.abort_if_blacklisted(); + + let near = env::attached_deposit(); + + // Select target account. + let account = to.unwrap_or_else(env::predecessor_account_id); + + Oracle::get_exchange_rate_promise() + .then(ext_self::buy_with_price_callback( + account.clone(), + near.into(), + expected, + env::current_account_id(), + NO_DEPOSIT, + GAS_FOR_BUY_PROMISE, + )) + // Returning callback promise, so the transaction will return the value or a failure. + // But the refund will still happen. + .as_return() + .then(ext_self::handle_refund( + account, + near.into(), + env::current_account_id(), + NO_DEPOSIT, + GAS_FOR_REFUND_PROMISE, + )); + } + + /// Completes the purchase (NEAR -> USN). It is called in 2 cases: + /// 1. Direct call from the `buy` method if the exchange rate cache is valid. + /// 2. Indirect callback from the cross-contract call after getting a fresh exchange rate. + fn finish_buy( + &mut self, + account: AccountId, + near: Balance, + expected: Option, + rate: ExchangeRate, + ) -> Balance { + if let Some(expected) = expected { + Self::assert_exchange_rate(&rate, &expected); + } + + let near = U256::from(near); + let multiplier = U256::from(rate.multiplier()); + + // Make exchange: NEAR -> USN. + let amount = near * multiplier / 10u128.pow(u32::from(rate.decimals() - USN_DECIMALS)); + + // Expected result (128-bit) can have 20 digits before and 18 after the decimal point. + // We don't expect more than 10^20 tokens on a single account. It panics if overflows. + let mut amount = amount.as_u128(); + + if account != self.owner_id { + // Commission. + let spread_denominator = 10u128.pow(SPREAD_DECIMAL as u32); + let commission_usn = + U256::from(amount) * U256::from(self.spread_u128(amount)) / spread_denominator; // amount * 0.005 + let commission_near = commission_usn + * U256::from(10u128.pow(u32::from(rate.decimals() - USN_DECIMALS))) + / multiplier; + + self.commission.usn += commission_usn.as_u128(); + self.commission.near += commission_near.as_u128(); + + // The final amount is going to be less than u128 after removing commission + amount = (U256::from(amount) - commission_usn).as_u128(); // amount * 0.995 + } + + if amount == 0 { + env::panic_str("Not enough NEAR: attached deposit exchanges to 0 tokens"); + } + + self.token.internal_deposit(&account, amount); + + event::emit::ft_mint(&account, amount, None); + + amount + } + + /// Sells USN tokens getting NEAR tokens. + /// Return amount of purchased NEAR tokens. + #[payable] + pub fn sell(&mut self, amount: U128, expected: Option) -> Promise { + assert_one_yocto(); + self.abort_if_pause(); + self.abort_if_blacklisted(); + + let amount = Balance::from(amount); + + if amount == 0 { + env::panic_str("Not allowed to sell 0 tokens"); + } + + let account = env::predecessor_account_id(); + + Oracle::get_exchange_rate_promise().then(ext_self::sell_with_price_callback( + account, + amount.into(), + expected, + env::current_account_id(), + NO_DEPOSIT, + GAS_FOR_SELL_PROMISE, + )) + } + + /// Finishes the sell (USN -> NEAR). It is called in 2 cases: + /// 1. Direct call from the `sell` method if the exchange rate cache is valid. + /// 2. Indirect callback from the cross-contract call after getting a fresh exchange rate. + fn finish_sell( + &mut self, + account: AccountId, + amount: Balance, + expected: Option, + rate: ExchangeRate, + ) -> Balance { + if let Some(expected) = expected { + Self::assert_exchange_rate(&rate, &expected); + } + + let mut sell_amount = U256::from(amount); + + if account != self.owner_id { + // Commission. + let spread_denominator = 10u128.pow(SPREAD_DECIMAL as u32); + let commission_usn = + U256::from(amount) * U256::from(self.spread_u128(amount)) / spread_denominator; + let commission_near = commission_usn + * U256::from(10u128.pow(u32::from(rate.decimals() - USN_DECIMALS))) + / rate.multiplier(); + self.commission.usn += commission_usn.as_u128(); + self.commission.near += commission_near.as_u128(); + + sell_amount -= commission_usn; + } + + // Make exchange: USN -> NEAR. + let deposit = sell_amount + * U256::from(10u128.pow(u32::from(rate.decimals() - USN_DECIMALS))) + / rate.multiplier(); + + // Here we don't expect too big deposit. Otherwise, panic. + let deposit = deposit.as_u128(); + + self.token.internal_withdraw(&account, amount); + + event::emit::ft_burn(&account, amount, None); + + deposit + } + + fn assert_exchange_rate(actual: &ExchangeRate, expected: &ExpectedRate) { + let slippage = u128::from(expected.slippage); + let multiplier = u128::from(expected.multiplier); + let start = multiplier.saturating_sub(slippage); + let end = multiplier.saturating_add(slippage); + assert_eq!( + actual.decimals(), + expected.decimals, + "Slippage error: different decimals" + ); + + if !(start..=end).contains(&actual.multiplier()) { + env::panic_str(&format!( + "Slippage error: fresh exchange rate {} is out of expected range {} +/- {}", + actual.multiplier(), + multiplier, + slippage + )); + } + } + + pub fn contract_status(&self) -> ContractStatus { + self.status.clone() + } + + /// Returns the name of the token. + pub fn name(&self) -> String { + let metadata = self.metadata.get(); + metadata.expect("Unable to get decimals").name + } + + /// Returns the symbol of the token. + pub fn symbol(&self) -> String { + let metadata = self.metadata.get(); + metadata.expect("Unable to get decimals").symbol + } + + /// Returns the decimals places of the token. + pub fn decimals(&self) -> u8 { + let metadata = self.metadata.get(); + metadata.expect("Unable to get decimals").decimals + } + + /// Returns either a fixed spread, or a adaptive spread + pub fn spread(&self, amount: Option) -> U128 { + let amount = amount.unwrap_or(U128::from(0)); + self.spread_u128(u128::from(amount)).into() + } + + fn spread_u128(&self, amount: u128) -> u128 { + match &self.spread { + Spread::Fixed(spread) => *spread, + Spread::Exponential(params) => { + // C1(v) = CHV + (CLV - CHV) * e ^ {-s1 * amount} + // CHV = 0.1% + // CLV = 0.5% + // s1 = 0.0000075 + // amount in [1, 10_000_000] + // Normalize amount to a number from $0 to $10,000,000. + + let decimals = 10u128.pow(USN_DECIMALS as u32); + let n = amount / decimals; // [0, ...], dropping decimals + let amount: u128 = if n > 10_000_000 { 10_000_000 } else { n }; // [0, 10_000_000] + let exp = (-params.scaler * amount as f64).exp(); + let spread = params.min + (params.max - params.min) * exp; + (spread * (10u32.pow(SPREAD_DECIMAL as u32) as f64)).round() as u128 + } + } + } + + pub fn set_fixed_spread(&mut self, spread: U128) { + self.assert_owner(); + let spread = Balance::from(spread); + if spread > MAX_SPREAD { + env::panic_str(&format!( + "Spread limit is {}%", + MAX_SPREAD / 10u128.pow(SPREAD_DECIMAL as u32) + )); + } + self.spread = Spread::Fixed(spread); + } + + pub fn set_adaptive_spread(&mut self, params: Option) { + self.assert_owner(); + + self.spread = match params { + None => Spread::Exponential(ExponentialSpreadParams::default()), + Some(params) => { + let max_spread = MAX_SPREAD as f64 / 10u64.pow(SPREAD_DECIMAL as u32) as f64; + if params.max < params.min { + env::panic_str("params.min cannot be greater than params.max"); + } + if params.min > max_spread { + env::panic_str(&format!("params.min is greater than {}", max_spread)); + } + if params.max > max_spread { + env::panic_str(&format!("params.max is greater than {}", max_spread)); + } + if params.scaler > SPREAD_MAX_SCALER { + #[rustfmt::skip] + env::panic_str(&format!("params.scaler is greater than {}", SPREAD_MAX_SCALER)); + } + if params.min.is_sign_negative() + || params.max.is_sign_negative() + || params.scaler.is_sign_negative() + { + env::panic_str("params.min, params.max, params.scaler cannot be negative"); + } + Spread::Exponential(params) + } + } + } + + pub fn version(&self) -> String { + format!("{}:{}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION")) + } + + pub fn commission(&self) -> CommissionOutput { + self.commission.clone().into() + } + + pub fn treasury(&self) -> TreasuryData { + self.treasury.get().expect("Valid treasury") + } + + /// This is NOOP implementation. KEEP IT if you haven't changed contract state. + /// Should only be called by this contract on migration. + /// This method is called from `upgrade()` method. + /// For next version upgrades, change this function. + #[init(ignore_state)] + #[private] + pub fn migrate() -> Self { + let contract: Self = env::state_read().expect("Contract is not initialized"); + contract + } + + fn abort_if_pause(&self) { + if self.status == ContractStatus::Paused { + env::panic_str("The contract is under maintenance") + } + } + + fn abort_if_blacklisted(&self) { + let account_id = env::predecessor_account_id(); + if self.blacklist_status(&account_id) != BlackListStatus::Allowable { + env::panic_str(&format!("Account '{}' is banned", account_id)); + } + } + + fn on_tokens_burned(&mut self, account_id: AccountId, amount: Balance) { + event::emit::ft_burn(&account_id, amount, None) + } +} + +#[no_mangle] +pub fn upgrade() { + env::setup_panic_hook(); + + let contract: Contract = env::state_read().expect("Contract is not initialized"); + contract.assert_owner(); + + const MIGRATE_METHOD_NAME: &[u8; 7] = b"migrate"; + const UPDATE_GAS_LEFTOVER: Gas = Gas(5_000_000_000_000); + + unsafe { + // Load code into register 0 result from the input argument if factory call or from promise if callback. + sys::input(0); + // Create a promise batch to update current contract with code from register 0. + let promise_id = sys::promise_batch_create( + env::current_account_id().as_bytes().len() as u64, + env::current_account_id().as_bytes().as_ptr() as u64, + ); + // Deploy the contract code from register 0. + sys::promise_batch_action_deploy_contract(promise_id, u64::MAX, 0); + // Call promise to migrate the state. + // Batched together to fail upgrade if migration fails. + sys::promise_batch_action_function_call( + promise_id, + MIGRATE_METHOD_NAME.len() as u64, + MIGRATE_METHOD_NAME.as_ptr() as u64, + 0, + 0, + 0, + (env::prepaid_gas() - env::used_gas() - UPDATE_GAS_LEFTOVER).0, + ); + sys::promise_return(promise_id); + } +} + +/// The core methods for a basic fungible token. Extension standards may be +/// added in addition to this macro. + +#[near_bindgen] +impl FungibleTokenCore for Contract { + #[payable] + fn ft_transfer(&mut self, receiver_id: AccountId, amount: U128, memo: Option) { + self.abort_if_pause(); + self.abort_if_blacklisted(); + self.token.ft_transfer(receiver_id, amount, memo); + } + + #[payable] + fn ft_transfer_call( + &mut self, + receiver_id: AccountId, + amount: U128, + memo: Option, + msg: String, + ) -> PromiseOrValue { + self.abort_if_pause(); + self.abort_if_blacklisted(); + self.token + .ft_transfer_call(receiver_id.clone(), amount, memo, msg) + } + + fn ft_total_supply(&self) -> U128 { + self.token.ft_total_supply() + } + + fn ft_balance_of(&self, account_id: AccountId) -> U128 { + self.token.ft_balance_of(account_id) + } +} + +#[near_bindgen] +impl FungibleTokenResolver for Contract { + #[private] + fn ft_resolve_transfer( + &mut self, + sender_id: AccountId, + receiver_id: AccountId, + amount: U128, + ) -> U128 { + let sender_id: AccountId = sender_id.into(); + let (used_amount, burned_amount) = + self.token + .internal_ft_resolve_transfer(&sender_id, receiver_id, amount); + if burned_amount > 0 { + self.on_tokens_burned(sender_id, burned_amount); + } + used_amount.into() + } +} + +#[near_bindgen] +impl FungibleTokenMetadataProvider for Contract { + fn ft_metadata(&self) -> FungibleTokenMetadata { + self.metadata.get().unwrap() + } +} + +#[cfg(all(test, not(target_arch = "wasm32")))] +mod tests { + use near_sdk::test_utils::{accounts, VMContextBuilder}; + use near_sdk::{testing_env, Balance, ONE_NEAR, ONE_YOCTO}; + + use super::*; + + impl From for ExpectedRate { + fn from(rate: ExchangeRate) -> Self { + Self { + multiplier: rate.multiplier().into(), + slippage: (rate.multiplier() * 5 / 100).into(), // 5% + decimals: rate.decimals(), + } + } + } + + fn get_context(predecessor_account_id: AccountId) -> VMContextBuilder { + let mut builder = VMContextBuilder::new(); + builder + .current_account_id(accounts(0)) + .signer_account_id(predecessor_account_id.clone()) + .predecessor_account_id(predecessor_account_id); + builder + } + + #[test] + fn test_new() { + const TOTAL_SUPPLY: Balance = 0; + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + let contract = Contract::new(accounts(1)); + testing_env!(context.is_view(true).build()); + assert_eq!(contract.ft_total_supply().0, TOTAL_SUPPLY); + assert_eq!(contract.ft_balance_of(accounts(1)).0, TOTAL_SUPPLY); + } + + #[test] + #[should_panic(expected = "The contract is not initialized")] + fn test_default() { + let context = get_context(accounts(1)); + testing_env!(context.build()); + let _contract = Contract::default(); + } + + #[test] + fn test_transfer() { + const AMOUNT: Balance = 3_000_000_000_000_000_000_000_000; + + let mut context = get_context(accounts(2)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(2)); + contract.token.internal_deposit(&accounts(2), AMOUNT); + + testing_env!(context + .storage_usage(env::storage_usage()) + .predecessor_account_id(accounts(1)) + .build()); + // Paying for account registration, aka storage deposit + + testing_env!(context + .storage_usage(env::storage_usage()) + .attached_deposit(ONE_YOCTO) + .predecessor_account_id(accounts(2)) + .build()); + let transfer_amount = AMOUNT / 3; + contract.ft_transfer(accounts(1), transfer_amount.into(), None); + + testing_env!(context + .storage_usage(env::storage_usage()) + .account_balance(env::account_balance()) + .is_view(true) + .attached_deposit(0) + .build()); + assert_eq!( + contract.ft_balance_of(accounts(2)).0, + (AMOUNT - transfer_amount) + ); + assert_eq!(contract.ft_balance_of(accounts(1)).0, transfer_amount); + } + + #[test] + fn test_blacklist() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(1)); + + // Act as a user. + testing_env!(context.predecessor_account_id(accounts(2)).build()); + + assert_eq!( + contract.blacklist_status(&accounts(1)), + BlackListStatus::Allowable + ); + + contract.token.internal_deposit(&accounts(2), 1000); + assert_eq!(contract.ft_balance_of(accounts(2)), U128::from(1000)); + + // Act as owner. + testing_env!(context.predecessor_account_id(accounts(1)).build()); + + contract.add_to_blacklist(&accounts(2)); + assert_eq!( + contract.blacklist_status(&accounts(2)), + BlackListStatus::Banned + ); + + contract.remove_from_blacklist(&accounts(2)); + assert_eq!( + contract.blacklist_status(&accounts(2)), + BlackListStatus::Allowable + ); + + contract.add_to_blacklist(&accounts(2)); + let total_supply_before = contract.token.total_supply; + + assert_ne!(contract.ft_balance_of(accounts(2)), U128::from(0)); + + contract.destroy_black_funds(&accounts(2)); + assert_ne!(total_supply_before, contract.token.total_supply); + + assert_eq!(contract.ft_balance_of(accounts(2)), U128::from(0)); + } + + #[test] + #[should_panic] + fn test_user_cannot_destroy_black_funds() { + let mut context = get_context(accounts(2)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(2)); + testing_env!(context + .storage_usage(env::storage_usage()) + .predecessor_account_id(accounts(1)) + .build()); + + contract.add_to_blacklist(&accounts(1)); + } + + #[test] + fn test_maintenance() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(1)); + testing_env!(context + .storage_usage(env::storage_usage()) + .attached_deposit(ONE_YOCTO) + .predecessor_account_id(accounts(1)) + .current_account_id(accounts(1)) + .signer_account_id(accounts(1)) + .build()); + assert_eq!(contract.contract_status(), ContractStatus::Working); + contract.pause(); + assert_eq!(contract.contract_status(), ContractStatus::Paused); + contract.resume(); + assert_eq!(contract.contract_status(), ContractStatus::Working); + contract.pause(); + contract.ft_total_supply(); + } + + #[test] + #[should_panic] + fn test_extend_guardians_by_user() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(1)); + testing_env!(context.predecessor_account_id(accounts(2)).build()); + contract.extend_guardians(vec![accounts(3)]); + } + + #[test] + fn test_guardians() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(1)); + testing_env!(context.predecessor_account_id(accounts(1)).build()); + contract.extend_guardians(vec![accounts(2)]); + assert!(contract.guardians.contains(&accounts(2))); + contract.remove_guardians(vec![accounts(2)]); + assert!(!contract.guardians.contains(&accounts(2))); + } + + #[test] + fn test_view_guardians() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(1)); + testing_env!(context.predecessor_account_id(accounts(1)).build()); + contract.extend_guardians(vec![accounts(2)]); + assert_eq!(contract.guardians()[0], accounts(2)); + contract.remove_guardians(vec![accounts(2)]); + assert_eq!(contract.guardians().len(), 0); + } + + #[test] + fn test_view_treasury() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + let contract = Contract::new(accounts(1)); + testing_env!(context.predecessor_account_id(accounts(1)).build()); + assert_eq!(contract.treasury(), TreasuryData::default()); + } + + #[test] + #[should_panic] + fn test_cannot_remove_guardians() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(1)); + testing_env!(context.predecessor_account_id(accounts(1)).build()); + contract.extend_guardians(vec![accounts(2)]); + assert!(contract.guardians.contains(&accounts(2))); + contract.remove_guardians(vec![accounts(3)]); + } + + #[test] + fn test_buy_sell() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + + let mut contract = Contract::new(accounts(1)); + + testing_env!(context.predecessor_account_id(accounts(2)).build()); + + testing_env!(context + .predecessor_account_id(accounts(2)) + .attached_deposit(ONE_NEAR) + .build()); + + let old_rate = ExchangeRate::test_old_rate(); + + contract.buy(None, None); + + testing_env!(context.attached_deposit(ONE_YOCTO).build()); + + contract.sell(U128::from(11032461000000000000), None); + + contract.buy(Some(old_rate.clone().into()), None); + + testing_env!(context.attached_deposit(ONE_YOCTO).build()); + + let mut expected_rate: ExpectedRate = old_rate.clone().into(); + expected_rate.multiplier = (old_rate.multiplier() * 96 / 100).into(); + + contract.sell(U128::from(9900000000000000000), Some(expected_rate)); + } + + #[test] + fn test_buy_auto_registration() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + + let mut contract = Contract::new(accounts(1)); + + testing_env!(context.predecessor_account_id(accounts(2)).build()); + contract.buy(None, None); + + testing_env!(context.attached_deposit(ONE_YOCTO).build()); + + contract.sell(U128::from(11032461000000000000), None); + } + + #[test] + #[should_panic(expected = "Account 'charlie' is banned")] + fn test_cannot_buy() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + + let mut contract = Contract::new(accounts(1)); + + contract.add_to_blacklist(&accounts(2)); // It'll cause panic on buy. + + testing_env!(context.predecessor_account_id(accounts(2)).build()); + + testing_env!(context + .predecessor_account_id(accounts(2)) + .attached_deposit(ONE_NEAR) + .build()); + contract.buy(None, None); + } + + #[test] + #[should_panic(expected = "Account 'charlie' is banned")] + fn test_cannot_sell() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + + let mut contract = Contract::new(accounts(1)); + + contract.add_to_blacklist(&accounts(2)); // It'll cause panic on sell. + + testing_env!(context.predecessor_account_id(accounts(2)).build()); + + testing_env!(context + .predecessor_account_id(accounts(2)) + .attached_deposit(ONE_YOCTO) + .build()); + contract.sell(U128::from(1), Some(ExchangeRate::test_old_rate().into())); + } + + #[test] + fn test_fixed_spread() { + let context = get_context(accounts(1)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(1)); + + contract.set_fixed_spread(MAX_SPREAD.into()); + assert_eq!(contract.spread(None).0, MAX_SPREAD); + let res = + std::panic::catch_unwind(move || contract.set_fixed_spread((MAX_SPREAD + 1).into())); + assert!(res.is_err()); + } + + #[test] + fn test_adaptive_spread() { + let context = get_context(accounts(1)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(1)); + + let one_token = 10u128.pow(contract.decimals() as u32); + let hundred_thousands = one_token * 100_000; + let ten_mln = one_token * 10_000_000; + + contract.set_adaptive_spread(None); + assert_eq!(contract.spread(Some(one_token.into())).0, 5000); // $1: 0.0050000 = 0.5% + assert_eq!(contract.spread(Some(hundred_thousands.into())).0, 2889); // $1000: 0.002889 = 0.289% + assert_eq!(contract.spread(Some(ten_mln.into())).0, 1000); // $10mln: 0.001000 = 0.1% + + contract.set_adaptive_spread(Some(ExponentialSpreadParams { + min: 0.002, + max: 0.006, + scaler: 0.00001, + })); + assert_eq!(contract.spread(Some(one_token.into())).0, 6000); // $1: 0.0060000 = 0.6% + assert_eq!(contract.spread(Some(hundred_thousands.into())).0, 3472); // $1000: 0.003472 = 0.347% + assert_eq!(contract.spread(Some(ten_mln.into())).0, 2000); // $10mln: 0.002000 = 021% + } + + #[test] + #[should_panic] + fn test_adaptive_spread_min_limit() { + let context = get_context(accounts(1)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(1)); + + contract.set_adaptive_spread(Some(ExponentialSpreadParams { + min: 0.06, + max: 0.001, + scaler: 0.00001, + })); + } + + #[test] + #[should_panic] + fn test_adaptive_spread_max_limit() { + let context = get_context(accounts(1)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(1)); + + contract.set_adaptive_spread(Some(ExponentialSpreadParams { + min: 0.001, + max: 0.06, + scaler: 0.00001, + })); + } + + #[test] + #[should_panic] + fn test_adaptive_spread_min_gt_max() { + let context = get_context(accounts(1)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(1)); + + contract.set_adaptive_spread(Some(ExponentialSpreadParams { + min: 0.002, + max: 0.001, + scaler: 0.00001, + })); + } + + #[test] + #[should_panic] + fn test_adaptive_spread_scaler_limit() { + let context = get_context(accounts(1)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(1)); + + contract.set_adaptive_spread(Some(ExponentialSpreadParams { + min: 0.001, + max: 0.002, + scaler: 0.5, + })); + } + + #[test] + #[should_panic] + fn test_adaptive_spread_negative_param() { + let context = get_context(accounts(1)); + testing_env!(context.build()); + let mut contract = Contract::new(accounts(1)); + + contract.set_adaptive_spread(Some(ExponentialSpreadParams { + min: -0.001, + max: -0.002, + scaler: 1.0, + })); + } + + #[test] + fn test_u256() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + + let mut contract = Contract::new(accounts(1)); + + testing_env!(context.predecessor_account_id(accounts(2)).build()); + + let fresh_rate = ExchangeRate::test_fresh_rate(); + let expected_rate: ExpectedRate = fresh_rate.clone().into(); + + assert_eq!( + contract.finish_buy( + accounts(2), + 1_000_000_000_000 * ONE_NEAR, + Some(expected_rate.clone()), + fresh_rate.clone(), + ), + 11132756100000_000000000000000000 + ); + + testing_env!(context + .account_balance(1_000_000_000_000 * ONE_NEAR) + .build()); + + assert_eq!( + contract.finish_sell( + accounts(2), + 11088180500000_000000000000000000, + Some(expected_rate), + fresh_rate, + ), + 994_005_000000000000000000000000000000 + ); + } + + #[test] + fn test_owner_buy_sell() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + + let mut contract = Contract::new(accounts(1)); + + testing_env!(context.predecessor_account_id(accounts(1)).build()); + + let fresh_rate = ExchangeRate::test_fresh_rate(); + let expected_rate: ExpectedRate = fresh_rate.clone().into(); + + assert_eq!( + contract.finish_buy( + accounts(1), + 1_000_000_000_000 * ONE_NEAR, + Some(expected_rate.clone()), + fresh_rate.clone(), + ), + 11143900000000_000000000000000000 + ); + + testing_env!(context + .account_balance(1_000_000_000_000 * ONE_NEAR) + .build()); + + assert_eq!( + contract.finish_sell( + accounts(1), + 11088180500000_000000000000000000, + Some(expected_rate), + fresh_rate, + ), + 995_000_000000000000000000000000000000 + ); + } + + #[test] + fn test_commission() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + + let mut contract = Contract::new(accounts(1)); + + testing_env!(context.predecessor_account_id(accounts(2)).build()); + + let fresh_rate = ExchangeRate::test_fresh_rate(); + let expected_rate: ExpectedRate = fresh_rate.clone().into(); + + contract.finish_buy( + accounts(2), + 1 * ONE_NEAR, + Some(expected_rate.clone()), + fresh_rate.clone(), + ); + assert_eq!(contract.commission().usn, U128(55_719_500_000_000_000)); + + assert_eq!( + contract.commission().near, + U128(5_000_000_000_000_000_000_000) + ); + + contract.finish_sell( + accounts(2), + 1_000_000_000_000_000, + Some(expected_rate.clone()), + fresh_rate, + ); + assert_eq!(contract.commission().usn, U128(55_724_500_000_000_000)); + + assert_eq!( + contract.commission().near, + U128(5_000_448_675_957_250_154_793) + ); + } + + #[test] + #[should_panic(expected = "The account doesn't have enough balance")] + fn test_not_enough_deposit() { + let mut context = get_context(accounts(1)); + testing_env!(context.build()); + + let mut contract = Contract::new(accounts(1)); + + testing_env!(context.predecessor_account_id(accounts(2)).build()); + + let fresh_rate = ExchangeRate::test_fresh_rate(); + let expected_rate: ExpectedRate = fresh_rate.clone().into(); + + contract.finish_sell( + accounts(2), + 11032461000000_000000000000000000, + Some(expected_rate), + fresh_rate, + ); + } +} diff --git a/src/oracle/mod.rs b/src/oracle/mod.rs new file mode 100644 index 0000000..fe4c87b --- /dev/null +++ b/src/oracle/mod.rs @@ -0,0 +1,8 @@ +mod oracle; +mod priceoracle; + +pub use oracle::*; + +// Exposing original priceoracle DTO allows to decrease +// gas consumption from 25 to 19 TGas (~24%). +pub use priceoracle::PriceData; diff --git a/src/oracle/oracle.rs b/src/oracle/oracle.rs new file mode 100644 index 0000000..75547c1 --- /dev/null +++ b/src/oracle/oracle.rs @@ -0,0 +1,111 @@ +use near_sdk::Timestamp; + +use crate::oracle::priceoracle::{ext_priceoracle, PriceData}; +use crate::*; + +struct OracleConfig { + pub oracle_address: &'static str, + pub asset_id: &'static str, + pub gas: Gas, +} + +const CONFIG: OracleConfig = if cfg!(feature = "mainnet") { + OracleConfig { + oracle_address: "priceoracle.near", + asset_id: "wrap.near", // NEARUSDT + gas: Gas(5_000_000_000_000), + } +} else if cfg!(feature = "testnet") { + OracleConfig { + oracle_address: "priceoracle.testnet", + asset_id: "wrap.testnet", // NEARUSDT + gas: Gas(5_000_000_000_000), + } +} else { + OracleConfig { + oracle_address: "priceoracle.test.near", + asset_id: "wrap.test.near", + gas: Gas(5_000_000_000_000), + } +}; + +#[derive(BorshSerialize, BorshDeserialize, Serialize, Deserialize, Clone)] +#[serde(crate = "near_sdk::serde")] +pub struct ExchangeRate { + multiplier: u128, + decimals: u8, + timestamp: Timestamp, + recency_duration: Timestamp, +} + +impl ExchangeRate { + pub fn multiplier(&self) -> u128 { + self.multiplier + } + + pub fn decimals(&self) -> u8 { + self.decimals + } +} + +#[derive(BorshSerialize, BorshDeserialize)] +pub struct Oracle { + pub last_report: Option, +} + +impl Default for Oracle { + fn default() -> Self { + Self { last_report: None } + } +} + +impl Oracle { + pub fn get_exchange_rate_promise() -> Promise { + ext_priceoracle::get_price_data( + vec![CONFIG.asset_id.into()], + CONFIG.oracle_address.parse().unwrap(), + 0, + CONFIG.gas, + ) + } +} + +impl From for ExchangeRate { + fn from(price_data: PriceData) -> Self { + let price = price_data.price(&CONFIG.asset_id.into()); + + if env::block_timestamp() >= price_data.timestamp() + price_data.recency_duration() { + env::panic_str("Oracle provided an outdated price data"); + } + + let exchange_rate = ExchangeRate { + multiplier: price.multiplier.into(), + decimals: price.decimals, + timestamp: price_data.timestamp(), + recency_duration: price_data.recency_duration(), + }; + + exchange_rate + } +} + +#[cfg(test)] +impl ExchangeRate { + pub fn test_fresh_rate() -> Self { + Self { + multiplier: 111439, + decimals: 28, + timestamp: env::block_timestamp(), + recency_duration: env::block_timestamp() + 1000000000, + } + } + + pub fn test_old_rate() -> Self { + Self { + multiplier: 111439, + decimals: 28, + timestamp: env::block_timestamp(), + recency_duration: env::block_timestamp(), + } + } +} diff --git a/src/oracle/priceoracle.rs b/src/oracle/priceoracle.rs new file mode 100644 index 0000000..53f247e --- /dev/null +++ b/src/oracle/priceoracle.rs @@ -0,0 +1,59 @@ +//! Interface to `priceoracle.near`. + +use near_sdk::{ext_contract, Timestamp}; + +use crate::*; + +// From https://github.com/NearDeFi/price-oracle/blob/main/src/*.rs +type AssetId = String; +type DurationSec = u32; + +// From https://github.com/NearDeFi/price-oracle/blob/main/src/utils.rs +#[derive(BorshSerialize, BorshDeserialize, Deserialize, Clone, Copy)] +#[serde(crate = "near_sdk::serde")] +pub struct Price { + pub multiplier: U128, + pub decimals: u8, +} + +// From https://github.com/NearDeFi/price-oracle/blob/main/src/asset.rs +#[derive(BorshSerialize, BorshDeserialize, Deserialize)] +#[serde(crate = "near_sdk::serde")] +pub struct AssetOptionalPrice { + pub asset_id: AssetId, + pub price: Option, +} + +// From https://github.com/NearDeFi/price-oracle/blob/main/src/lib.rs +#[derive(BorshSerialize, BorshDeserialize, Deserialize)] +#[serde(crate = "near_sdk::serde")] +pub struct PriceData { + timestamp: U64, + recency_duration_sec: DurationSec, + prices: Vec, +} + +impl PriceData { + pub fn timestamp(&self) -> Timestamp { + Timestamp::from(self.timestamp) + } + + pub fn recency_duration(&self) -> Timestamp { + Timestamp::from(self.recency_duration_sec) * 10u64.pow(9) + } + + pub fn price(&self, asset: &AssetId) -> Price { + let asset_error = format!("Oracle has NOT provided an exchange rate for {}", asset); + self.prices + .iter() + .find(|aop| &aop.asset_id == asset) + .expect(&asset_error) + .price + .expect(&asset_error) + } +} + +#[ext_contract(ext_priceoracle)] +pub trait PriceOracle { + fn get_price_data(&self, asset_ids: Vec) -> PriceData; +} diff --git a/src/owner.rs b/src/owner.rs new file mode 100644 index 0000000..cd0c9cf --- /dev/null +++ b/src/owner.rs @@ -0,0 +1,49 @@ +use crate::*; + +#[near_bindgen] +impl Contract { + pub(crate) fn assert_owner(&self) { + if env::predecessor_account_id() != self.owner_id { + env::panic_str("This method can be called only by owner") + } + } + + pub(crate) fn assert_owner_or_guardian(&self) { + let predecessor_id = env::predecessor_account_id(); + if predecessor_id != self.owner_id && !self.guardians.contains(&predecessor_id) { + env::panic_str("This method can be called only by owner or guardian") + } + } + + pub fn set_owner(&mut self, owner_id: AccountId) { + self.assert_owner(); + self.owner_id = owner_id; + } + + pub fn owner(&self) -> AccountId { + self.owner_id.clone() + } + + /// Extend guardians. Only can be called by owner. + #[payable] + pub fn extend_guardians(&mut self, guardians: Vec) { + self.assert_owner(); + for guardian in guardians { + self.guardians.insert(&guardian); + } + } + + /// Remove guardians. Only can be called by owner. + pub fn remove_guardians(&mut self, guardians: Vec) { + self.assert_owner(); + for guardian in guardians { + if !self.guardians.remove(&guardian) { + env::panic_str(&format!("The guardian '{}' doesn't exist", guardian)); + } + } + } + + pub fn guardians(&self) -> Vec { + self.guardians.to_vec() + } +} diff --git a/src/storage.rs b/src/storage.rs new file mode 100644 index 0000000..f15f115 --- /dev/null +++ b/src/storage.rs @@ -0,0 +1,16 @@ +use crate::*; + +use near_contract_standards::storage_management::StorageBalance; + +#[near_bindgen] +impl Contract { + /// Always returns 125 milliNEAR indicating that user doesn't need to be registered. + /// It's a workaround for integrations required NEP-125 storage compatibility. + pub fn storage_balance_of(&self, account_id: AccountId) -> Option { + let _ = account_id; + Some(StorageBalance { + total: 1250000000000000000000.into(), + available: 0.into(), + }) + } +} diff --git a/src/treasury/balance_stable_pool.rs b/src/treasury/balance_stable_pool.rs new file mode 100644 index 0000000..edd5667 --- /dev/null +++ b/src/treasury/balance_stable_pool.rs @@ -0,0 +1,255 @@ +use std::collections::HashMap; + +use crate::*; + +use super::ft::REF_DEPOSIT_ACTION; +use super::gas::*; +use super::pool::{extend_decimals, remove_decimals, Pool}; +use super::ref_finance::*; + +use near_sdk::require; + +#[near_bindgen] +impl Contract { + #[payable] + pub fn balance_stable_pool(&mut self, pool_id: u64) -> Promise { + self.assert_owner_or_guardian(); + + // 1st yoctoNEAR is for add_stable_liquidity/remove_stable_liquidity. + require!( + env::attached_deposit() > 0, + "Requires attached deposit at least 1 yoctoNEAR" + ); + + let pool = Pool::from_config_with_assert(pool_id); + + ext_ref_finance::get_stable_pool(pool.id, pool.ref_id.clone(), 0, GAS_FOR_GET_DEPOSITS) + .and(ext_ref_finance::get_deposits( + env::current_account_id(), + pool.ref_id, + NO_DEPOSIT, + GAS_FOR_GET_DEPOSITS, + )) + .then(ext_self::handle_start_balancing( + pool.id, + env::current_account_id(), + env::attached_deposit(), + GAS_FOR_FT_TRANSFER_CALL + GAS_FOR_WITHDRAW + GAS_FOR_FINISH_BURNING + GAS_SURPLUS, + )) + } +} + +#[ext_contract(ext_self)] +trait RefFinanceHandler { + #[private] + #[payable] + fn handle_start_balancing( + &mut self, + pool_id: u64, + #[callback] info: StablePoolInfo, + #[callback] deposits: HashMap, + ) -> PromiseOrValue<()>; + + #[private] + fn finish_balancing_with_burn(&mut self, amount: U128); +} + +trait RefFinanceHandler { + fn handle_start_balancing( + &mut self, + pool_id: u64, + info: StablePoolInfo, + deposits: HashMap, + ) -> PromiseOrValue<()>; + + fn finish_balancing_with_burn(&mut self, amount: U128); +} + +#[near_bindgen] +impl RefFinanceHandler for Contract { + #[private] + #[payable] + fn handle_start_balancing( + &mut self, + pool_id: u64, + #[callback] info: StablePoolInfo, + #[callback] deposits: HashMap, + ) -> PromiseOrValue<()> { + let pool = Pool::from_config_with_assert(pool_id); + let count = info.amounts.len() as u128; + + require!( + pool.tokens == info.token_account_ids, + "Wrong pool structure" + ); + + let normalized_amounts = + pool.decimals + .iter() + .zip(info.amounts) + .map(move |(&decimals, amount)| { + if decimals < USN_DECIMALS { + extend_decimals(amount.into(), USN_DECIMALS - decimals) + } else if decimals > USN_DECIMALS { + remove_decimals(amount.into(), decimals) + } else { + amount.into() + } + }); + + let pairs = pool.tokens.iter().zip(normalized_amounts); + + let usn_id = env::current_account_id(); + + let usn = pairs + .clone() + .find_map(|(token_id, amount)| { + if token_id == &usn_id { + Some(amount) + } else { + None + } + }) + .unwrap(); + let rest = pairs.clone().filter_map(|(token_id, amount)| { + if token_id != &usn_id { + Some(amount) + } else { + None + } + }); + + let rest_count = rest.clone().count(); + + require!( + rest_count == pool.tokens.len() - 1, + "Wrong number of tokens in the pool" + ); + + let average = rest.sum::() / (count - 1); + + if usn < average { + // mint -> deposit -> add liquidity + + let to_add = average - usn; + + let usn_balance = self.token.internal_unwrap_balance_of(&usn_id); + let usn_deposit = deposits.get(&usn_id).unwrap_or(&U128::from(0u128)).0; + + // Deposit. + let maybe_deposit = if usn_deposit < to_add { + let yet_to_deposit = to_add - usn_deposit; + + // Mint necessary USN amount. + if usn_balance < yet_to_deposit { + let yet_to_mint = yet_to_deposit - usn_balance; + self.token.internal_deposit(&usn_id, yet_to_mint); + event::emit::ft_mint(&usn_id, yet_to_mint, None); + } + + Some(self.token.internal_transfer_call( + &usn_id, + &pool.ref_id, + yet_to_deposit, + GAS_FOR_FT_TRANSFER_CALL, + None, + REF_DEPOSIT_ACTION.to_string(), + )) + } else { + None + }; + + // Preserve the sequence of token amounts. + let liquidity_amounts = info + .token_account_ids + .iter() + .map(|token| { + if *token == usn_id { + // Add minted USN. + U128::from(to_add) + } else { + U128::from(0) + } + }) + .collect::>(); + + let min_shares = NO_DEPOSIT.into(); + + // Add liquidity. + let add_liquidity = ext_ref_finance::add_stable_liquidity( + pool.id, + liquidity_amounts, + min_shares, + pool.ref_id, + env::attached_deposit(), + GAS_FOR_ADD_LIQUIDITY, + ); + + // Chain the calls. + if let Some(add_deposit) = maybe_deposit { + add_deposit.then(add_liquidity).into() + } else { + add_liquidity.into() + } + } else if usn > average { + // remove_liquidity -> withdraw -> burn. + + // Mint. + let to_burn = usn - average; + + let burn_amounts = info + .token_account_ids + .iter() + .map(|token| { + if *token == usn_id { + // Remove USN. + U128::from(to_burn) + } else { + U128::from(0) + } + }) + .collect::>(); + + let max_burn_shares = info.shares_total_supply; + + // Remove liquidity. + ext_ref_finance::remove_liquidity_by_tokens( + pool.id, + burn_amounts, + max_burn_shares, + pool.ref_id.clone(), + 1, + GAS_FOR_REMOVE_LIQUIDITY, + ) + // Withdraw. + .then(ext_ref_finance::withdraw( + usn_id.clone(), + to_burn.into(), + None, + pool.ref_id, + 1, + GAS_FOR_WITHDRAW, + )) + // Burn. + .then(ext_self::finish_balancing_with_burn( + to_burn.into(), + usn_id, + NO_DEPOSIT, + GAS_FOR_FINISH_BURNING, + )) + .into() + } else { + // Do nothing. + PromiseOrValue::Value(()) + } + } + + #[private] + fn finish_balancing_with_burn(&mut self, amount: U128) { + if is_promise_success() { + self.token + .internal_withdraw(&env::current_account_id(), amount.into()); + event::emit::ft_burn(&env::current_account_id(), amount.into(), None); + } + } +} diff --git a/src/treasury/balance_treasury.rs b/src/treasury/balance_treasury.rs new file mode 100644 index 0000000..7889a90 --- /dev/null +++ b/src/treasury/balance_treasury.rs @@ -0,0 +1,524 @@ +use easy_ml::matrices::Matrix; +use near_sdk::{require, ONE_NEAR, ONE_YOCTO}; +use partial_min_max::{max, min}; + +use crate::*; + +use super::ft::ext_ft; +#[cfg(not(feature = "mainnet"))] +use super::ft::REF_DEPOSIT_ACTION; +use super::gas::*; +use super::pool::{Pool, USDT_DECIMALS}; +use super::ref_finance::*; + +const NEAR_DECIMALS: u8 = 24; + +struct TreasuryConfig { + pub wrap_id: &'static str, + #[cfg(not(feature = "mainnet"))] + pub swap_pool_id: u64, +} + +const CONFIG: TreasuryConfig = if cfg!(feature = "mainnet") { + TreasuryConfig { + wrap_id: "wrap.near", + #[cfg(not(feature = "mainnet"))] + swap_pool_id: 4, + } +} else if cfg!(feature = "testnet") { + TreasuryConfig { + wrap_id: "wrap.testnet", + #[cfg(not(feature = "mainnet"))] + swap_pool_id: 34, + } +} else { + TreasuryConfig { + wrap_id: "wrap.test.near", + #[cfg(not(feature = "mainnet"))] + swap_pool_id: 3, + } +}; + +#[derive(BorshDeserialize, BorshSerialize, Debug, Serialize, PartialEq, Deserialize)] +#[serde(crate = "near_sdk::serde")] +pub enum TreasuryDecision { + Buy(f64), + Sell(f64), + DoNothing, +} + +impl std::fmt::Display for TreasuryDecision { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + TreasuryDecision::Buy(amount) => { + write!(f, "Treasury decision is to buy ${} USDT", amount) + } + TreasuryDecision::Sell(amount) => { + write!(f, "Treasury decision is to sell ${} USDT", amount) + } + TreasuryDecision::DoNothing => write!(f, "Treasury decision is to do nothing"), + } + } +} + +enum UpdateReserveAction { + Add(u128), + Sub(u128), +} + +#[near_bindgen] +impl Contract { + #[payable] + pub fn balance_treasury(&mut self, pool_id: u64) -> PromiseOrValue<()> { + self.assert_owner_or_guardian(); + + // Buy case: 2 yoctoNEAR, sell case: 3 yoctoNEAR. + require!( + env::attached_deposit() == 3 * ONE_YOCTO, + "3 yoctoNEAR of attached deposit is required" + ); + + let pool = Pool::from_config_with_assert(pool_id); + let treasury = self.treasury.get().expect("Valid treasury"); + + #[cfg(feature = "mainnet")] + let _ = pool; + + require!( + treasury.reserve.len() == 1, + "It's expected to have exactly one token in the reserve" + ); + + // Prepare input data to make decision about balancing. + + // 1. NEAR/USDT exchange rates. Warming the cache if it's not ready. + let (time_points, exchange_rates) = match treasury.cache.collect(env::block_timestamp()) { + Ok((time_points, exchange_rates)) => (time_points, exchange_rates), + Err(_) => env::panic_str("Treasury cache is not warmed up. Use `warmup`."), + }; + + // 2. NEAR part of USN reserve in NEAR. + let near = U128::from(env::account_balance() - env::attached_deposit()); + + // 3. Total value of issued USN. + let usn = self.token.ft_total_supply(); + + // 4. USDT reserve. The first non-USN token currently. + let (_, &usdt) = treasury.reserve.iter().next().expect("USDT reserve"); + + // Convert everything into floats. + let near = near.0 as f64 / ONE_NEAR as f64; + let usn = usn.0 as f64 / 10u128.pow(USN_DECIMALS as u32) as f64; + #[cfg(not(feature = "mainnet"))] + let last_exchange_rate = *exchange_rates.last().unwrap(); + let usdt = usdt.0 as f64 / 10f64.powi(USDT_DECIMALS as i32); + + // Make a decision. + let decision = make_treasury_decision(exchange_rates, time_points, near, usn, usdt); + + env::log_str(format!("{}", decision).as_str()); + + #[cfg(not(feature = "mainnet"))] + match decision { + TreasuryDecision::DoNothing => PromiseOrValue::Value(()), + TreasuryDecision::Buy(f_amount) => buy(pool.id, f_amount, last_exchange_rate).into(), + TreasuryDecision::Sell(f_amount) => sell(pool.id, f_amount, last_exchange_rate).into(), + } + + #[cfg(feature = "mainnet")] + PromiseOrValue::Value(()) + } + + pub fn warmup(&mut self) -> Promise { + Oracle::get_exchange_rate_promise().then(ext_self::handle_exchange_rate_cache( + env::current_account_id(), + NO_DEPOSIT, + GAS_FOR_HANDLE_EXCHANGE_RATE, + )) + } +} + +#[cfg(not(feature = "mainnet"))] +fn buy(pool_id: u64, amount: f64, exchange_rate: f64) -> Promise { + let wrap_id: AccountId = CONFIG.wrap_id.parse().unwrap(); + let pool = Pool::from_config_with_assert(pool_id); + let near = ((amount / exchange_rate) * ONE_NEAR as f64) as u128; + // TODO: 50% slippage is because it gets less than expected. Need to figure out. + let min_amount = (amount * 0.50 * 10f64.powi(USDT_DECIMALS as i32)) as u128; + + env::log_str(&format!("Trying to wrap {} NEAR", near)); + + let usdt_name = pool + .tokens + .iter() + .find(|&token_id| token_id != &env::current_account_id()) + .unwrap(); + + let swap_action = SwapAction { + pool_id: CONFIG.swap_pool_id, + amount_in: Some(near.into()), + token_in: wrap_id.clone(), + token_out: usdt_name.clone(), + min_amount_out: U128(min_amount), + }; + + ext_ft::near_deposit(wrap_id.clone(), near, GAS_FOR_NEAR_DEPOSIT) + .then(ext_ft::ft_transfer_call( + pool.ref_id.clone(), + near.into(), + None, + REF_DEPOSIT_ACTION.into(), + wrap_id, + ONE_YOCTO, + GAS_FOR_FT_TRANSFER_CALL, + )) + .then(ext_ref_finance::swap( + vec![swap_action], + None, + pool.ref_id.clone(), + NO_DEPOSIT, + GAS_FOR_SWAP, + )) + .then(ext_self::handle_liquidity_after_swap( + pool.id, + env::current_account_id(), + ONE_YOCTO, + GAS_SURPLUS + GAS_FOR_WITHDRAW, + )) +} + +#[cfg(not(feature = "mainnet"))] +fn sell(pool_id: u64, amount: f64, exchange_rate: f64) -> Promise { + let wrap_id = CONFIG.wrap_id.parse().unwrap(); + let pool = Pool::from_config_with_assert(pool_id); + let usdt_amount = (amount * 10f64.powi(USDT_DECIMALS as i32)) as u128; + // TODO: 50% slippage is because it gets less than expected. Need to figure out. + let min_amount = ((amount * 0.50 / exchange_rate) * 10f64.powi(USN_DECIMALS as i32)) as u128; + + let usdt_name = pool + .tokens + .iter() + .find(|&token_id| token_id != &env::current_account_id()) + .unwrap(); + + let swap_action = SwapAction { + pool_id: CONFIG.swap_pool_id, + amount_in: Some(U128(usdt_amount)), + token_in: usdt_name.clone(), + token_out: wrap_id, + min_amount_out: min_amount.into(), + }; + + let max_burn_shares = U128(u128::MAX); // TODO: Any limits? + + let remove_amounts = pool + .tokens + .iter() + .map(|token_id| { + if token_id == &env::current_account_id() { + U128(0u128) + } else { + U128(usdt_amount) + } + }) + .collect(); + + ext_ref_finance::remove_liquidity_by_tokens( + pool.id, + remove_amounts, + max_burn_shares, + pool.ref_id.clone(), + ONE_YOCTO, + GAS_FOR_REMOVE_LIQUIDITY, + ) + .then(ext_ref_finance::swap( + vec![swap_action], + None, + pool.ref_id, + NO_DEPOSIT, + GAS_FOR_SWAP, + )) + .then(ext_self::handle_withdraw_after_swap( + pool.id, + usdt_amount.into(), + env::current_account_id(), + 2 * ONE_YOCTO, + GAS_SURPLUS * 2 + GAS_FOR_WITHDRAW + GAS_FOR_NEAR_WITHDRAW, + )) +} + +#[ext_contract(ext_self)] +trait SelfHandler { + #[private] + #[payable] + fn handle_withdraw_after_swap( + &mut self, + pool_id: u64, + usdt_amount: U128, + #[callback] wrap_amount: U128, + ) -> Promise; + + #[private] + #[payable] + fn handle_liquidity_after_swap(&mut self, pool_id: u64, #[callback] amount: U128) -> Promise; + + #[private] + fn handle_exchange_rate_cache(&mut self, #[callback] price: PriceData); +} + +trait SelfHandler { + fn handle_withdraw_after_swap( + &mut self, + pool_id: u64, + usdt_amount: U128, + wrap_amount: U128, + ) -> Promise; + + fn handle_liquidity_after_swap(&mut self, pool_id: u64, amount: U128) -> Promise; + + fn handle_exchange_rate_cache(&mut self, price: PriceData); +} + +#[near_bindgen] +impl SelfHandler for Contract { + #[private] + #[payable] + fn handle_withdraw_after_swap( + &mut self, + pool_id: u64, + usdt_amount: U128, + #[callback] wrap_amount: U128, + ) -> Promise { + let wrap_id: AccountId = CONFIG.wrap_id.parse().unwrap(); + let pool = Pool::from_config_with_assert(pool_id); + + self.update_reserve(UpdateReserveAction::Sub(usdt_amount.into())); + + ext_ref_finance::withdraw( + wrap_id.clone(), + wrap_amount, + None, + pool.ref_id, + ONE_YOCTO, + GAS_FOR_WITHDRAW, + ) + .then(ext_ft::near_withdraw( + wrap_amount, + wrap_id, + ONE_YOCTO, + GAS_FOR_NEAR_WITHDRAW, + )) + } + + #[private] + #[payable] + fn handle_liquidity_after_swap(&mut self, pool_id: u64, #[callback] amount: U128) -> Promise { + let pool = Pool::from_config_with_assert(pool_id); + + self.update_reserve(UpdateReserveAction::Add(amount.into())); + + let add_amounts = pool + .tokens + .iter() + .map(|token_id| { + if token_id == &env::current_account_id() { + U128(0u128) + } else { + amount + } + }) + .collect(); + + let min_shares = U128::from(0u128); // TODO: Any limits? + + ext_ref_finance::add_stable_liquidity( + pool.id, + add_amounts, + min_shares, + pool.ref_id, + ONE_YOCTO, + GAS_FOR_ADD_LIQUIDITY, + ) + } + + #[private] + fn handle_exchange_rate_cache(&mut self, #[callback] price: PriceData) { + let mut treasury = self.treasury.take().unwrap(); + let rate: ExchangeRate = price.into(); + let rate = rate.multiplier() as f64 / 10f64.powi((rate.decimals() - NEAR_DECIMALS) as i32); + treasury.cache.append(env::block_timestamp(), rate); + self.treasury.replace(&treasury); + } +} + +impl Contract { + fn update_reserve(&mut self, action: UpdateReserveAction) { + let mut treasury = self.treasury.take().expect("Valid treasury"); + require!(treasury.reserve.len() == 1); + for (_, val) in treasury.reserve.iter_mut() { + match action { + UpdateReserveAction::Add(amount) => *val = U128(val.0 + amount), + UpdateReserveAction::Sub(amount) => *val = U128(val.0 - amount), + } + } + self.treasury.replace(&treasury); + } +} + +fn make_treasury_decision( + exchange_rates: Vec, + time_points: Vec, + near: f64, + usn: f64, + usdt: f64, +) -> TreasuryDecision { + // 1. Set constant values for further calculations + const M: i32 = 4; + const N_DN: f64 = 0.25; + const U_UP: f64 = 1.1; + const U_DN: f64 = 1.; + const P_DN: f64 = 0.6; + const P_UP: f64 = 0.7; + const T_BUY_MIN: f64 = 1000.; + const T_SELL_MIN: f64 = 1000.; + const T_BUY_STEP: f64 = 3_000_000.; + const T_SELL_STEP: f64 = 3_000_000.; + const T_0: f64 = 0.; + + let n = near; + let q = usn; + let u = usdt; + + debug_assert_eq!(exchange_rates.len(), time_points.len()); + debug_assert_eq!(exchange_rates.len(), 8); + + // 2. Set NER = ER[t − 0] = V8 + let n_er = exchange_rates.last().unwrap(); + + // 3. Make the data smoothing with moving average + let mut x: Vec = Vec::new(); + let mut y: Vec = Vec::new(); + for k in 1..7 { + x.push((time_points[k - 1] + time_points[k] + time_points[k + 1]) / 3.); + y.push((exchange_rates[k - 1] + exchange_rates[k] + exchange_rates[k + 1]) / 3.); + } + + // 4. Fit a quadratic trend into the 6 NEAR/USDT smoothed exchange rate values collected using OLS: + let x: Matrix = Matrix::column(x); + let y: Matrix = Matrix::column(y); + + let mut basis = x.clone(); + basis.insert_column(0, 1.0); + basis.insert_column_with(2, x.column_iter(0).map(|x| x * x)); + + let w = (basis.transpose() * &basis).inverse().unwrap() * (basis.transpose() * &y); + + // 5. Get coefficients a, b, c and R2 for this trend + let a = w.get(2, 0); + let b = w.get(1, 0); + let c = w.get(0, 0); + + // Stot = ∑((Y − Y _mean)2) + let er_mean: f64 = exchange_rates.clone().iter().sum::() / exchange_rates.len() as f64; + + let s_tot = exchange_rates + .clone() + .iter() + .map(|er| (er - er_mean).powi(2)) + .sum::(); + + // Sres = ∑(Vk − (a · Tk^2 + b · Tk + c))2 + let mut s_res: f64 = 0.; + for n in 0..exchange_rates.len() { + s_res += + (exchange_rates[n] - (time_points[n].powi(2) * a + time_points[n] * b + c)).powi(2); + } + + // R2 = 1 − Sres/Stot + let r_squared = 1. - s_res / s_tot; + + // 5. Calculate coefficient C + // C = sign(a) · R^2/(t0 + b/2a)^m + 1) + let c = f64::signum(a) * r_squared / ((T_0 + b / (2. * a)).powi(M) + 1.); + + if N_DN * q - n_er * n >= 0. { + let r_sell = min(min(N_DN * q - n_er * n, T_SELL_STEP), u); + + if r_sell >= T_SELL_MIN { + TreasuryDecision::Sell(r_sell) + } else { + TreasuryDecision::DoNothing + } + } else if N_DN * q - n_er * n < 0. && c > 0. { + let u_sell = max(c * (u - min(P_UP * (u + n_er * n), U_UP * q)), 0.); + + let r_sell = min(min(u_sell, T_SELL_STEP), u); + + if r_sell >= T_SELL_MIN { + TreasuryDecision::Sell(r_sell) + } else { + TreasuryDecision::DoNothing + } + } else { + let u_buy = c * min(u - min(P_DN * (u + n_er * n), U_DN * q), 0.); + + let r_buy = min(min(u_buy, T_BUY_STEP), n_er * n); + + if r_buy >= T_BUY_MIN { + TreasuryDecision::Buy(r_buy) + } else { + TreasuryDecision::DoNothing + } + } +} + +#[cfg(all(test, not(target_arch = "wasm32")))] +mod tests { + use super::*; + + #[test] + fn test_make_treasury_decision_sell() { + let treasury_decision = make_treasury_decision( + vec![6.615, 6.62, 6.628, 6.623, 6.578, 6.6, 6.577, 6.611], + vec![-7., -6., -5., -4., -3., -2., -1., -0.], + 191937460.53121, + 1241195491.76577, + 1367351872.04769, + ); + + assert_eq!( + treasury_decision, + TreasuryDecision::Sell(23604.588213058174) + ); + } + + #[test] + fn test_make_treasury_decision_do_nothing() { + let treasury_decision = make_treasury_decision( + vec![ + 5.9519, 5.9222, 5.9189, 5.9242, 5.9194, 5.9173, 5.8818, 5.8741, + ], + vec![-7., -6., -5., -4., -3., -2., -1., -0.], + 167242050.870139, + 1001497797.34406, + 1000522964.94309, + ); + + assert_eq!(treasury_decision, TreasuryDecision::DoNothing); + } + + #[test] + fn test_make_treasury_decision_buy() { + let treasury_decision = make_treasury_decision( + vec![ + 5.6584, 5.809, 5.7635, 5.8331, 5.8555, 5.8643, 5.8565, 5.8699, + ], + vec![-7., -6., -5., -4., -3., -2., -1., -0.], + 167270746.338665, + 1001096736.9184, + 1000039562.72316, + ); + + assert_eq!(treasury_decision, TreasuryDecision::Buy(207013.8891493543)); + } +} diff --git a/src/treasury/cache.rs b/src/treasury/cache.rs new file mode 100644 index 0000000..30e6ffd --- /dev/null +++ b/src/treasury/cache.rs @@ -0,0 +1,207 @@ +use near_sdk::Timestamp; + +use crate::*; + +const MAX_CACHE_SIZE: usize = 8; +const FIVE_MINUTES: Timestamp = 5 * 60 * 1000_000_000; + +#[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)] +#[cfg_attr(test, derive(Debug, PartialEq))] +#[serde(crate = "near_sdk::serde")] +pub struct CacheItem { + pub timestamp: Timestamp, + pub value: f64, + pub n: u8, +} + +impl CacheItem { + /// Returns an identifier of an interval which is 5 minutes long. + pub fn time_slot(&self) -> u64 { + self.timestamp / FIVE_MINUTES + } + + /// Normalized time: 5 minutes - > 1.0, -5 minutes -> -1.0, -15 minutes -> -3. + pub fn normalized_time(&self, now: Timestamp) -> f64 { + if self.timestamp > now { + return (self.timestamp - now) as f64 / FIVE_MINUTES as f64; + } else { + return -((now - self.timestamp) as f64) / FIVE_MINUTES as f64; + } + } +} + +#[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)] +#[cfg_attr(test, derive(Debug, PartialEq))] +#[serde(crate = "near_sdk::serde")] +pub struct IntervalCache { + pub items: Vec, +} + +impl Default for IntervalCache { + fn default() -> Self { + Self { + items: Vec::default(), + } + } +} + +#[cfg_attr(test, derive(Debug, PartialEq))] +pub enum CacheError { + NotReady, + Gaps, +} + +impl IntervalCache { + /// Stores a new value into time-aligned evenly distributed series, + /// 8 values in series at most. + /// + /// Strategy is averaging values in the 5 minute slot updating a timestamp. + /// For example, there are measurements at some moments of time: + /// ```text + /// time: 00:01 00:04 00:06 00:09 00:10 00:13 00:14 00:17 + /// value: 7.2 6.9 7.1 7.4 7.9 8.1 7.8 7.5 + /// ``` + /// The cache will have these values: + /// ```text + /// time: 00:04 00:09 00:14 00:17 + /// value: avg(7.2,6.9) avg(7.1,7.4) avg(7.9,8.1,7.8) 7.5 + /// ``` + /// effectively keeping a monotonic interval (~5 minutes) between cached values. + /// + pub fn append(&mut self, timestamp: Timestamp, value: f64) { + let mut new_item = CacheItem { + timestamp, + value, + n: 1, + }; + + if let Some(last_item) = self.items.last_mut() { + if last_item.time_slot() == new_item.time_slot() { + let n = last_item.n; + if n < u8::MAX { + let value = (last_item.value * n as f64 + new_item.value) / (n as f64 + 1.); + new_item.value = value; + new_item.n += n; + *last_item = new_item; + } + } else { + self.items.push(new_item); + } + } else { + self.items.push(new_item); + } + + if self.items.len() > MAX_CACHE_SIZE { + self.items.remove(0); + } + } + + pub fn collect(&self, now: Timestamp) -> Result<(Vec, Vec), CacheError> { + if self.items.len() < MAX_CACHE_SIZE { + return Result::Err(CacheError::NotReady); + } + + let mut x = Vec::::new(); + let mut y = Vec::::new(); + + let mut fresh_time_slot = self.items.last().unwrap().time_slot(); + + for item in self.items.iter().rev() { + if fresh_time_slot - item.time_slot() > 1 { + return Result::Err(CacheError::Gaps); + } + + x.push(item.normalized_time(now)); + y.push(item.value); + fresh_time_slot = item.time_slot(); + } + + x.reverse(); + y.reverse(); + + Result::Ok((x, y)) + } +} + +#[cfg(all(test, not(target_arch = "wasm32")))] +mod tests { + use super::*; + + #[test] + fn test_cache_insert() { + const ONE_MINUTE: u64 = FIVE_MINUTES / 5; + const RANDOM_NANO_SEC: u64 = 123456; + + let mut cache = IntervalCache::default(); + + cache.append(ONE_MINUTE, 7.2); + cache.append(4 * ONE_MINUTE, 6.9); + cache.append(6 * ONE_MINUTE, 7.1); + cache.append(9 * ONE_MINUTE + RANDOM_NANO_SEC, 7.4); + cache.append(10 * ONE_MINUTE, 7.9); + cache.append(13 * ONE_MINUTE, 8.1); + cache.append(14 * ONE_MINUTE, 7.8); + cache.append(17 * ONE_MINUTE, 7.5); + + assert_eq!( + vec![ + CacheItem { + timestamp: 4 * ONE_MINUTE, + value: (7.2 + 6.9) / 2., + n: 2, + }, + CacheItem { + timestamp: 9 * ONE_MINUTE + RANDOM_NANO_SEC, + value: (7.1 + 7.4) / 2., + n: 2, + }, + CacheItem { + timestamp: 14 * ONE_MINUTE, + value: (7.9 + 8.1 + 7.8) / 3., + n: 3, + }, + CacheItem { + timestamp: 17 * ONE_MINUTE, + value: 7.5, + n: 1, + } + ], + cache.items + ); + } + + #[test] + fn test_cache_collect_not_ready() { + const ONE_MINUTE: u64 = FIVE_MINUTES / 5; + + let mut cache = IntervalCache::default(); + + cache.append(ONE_MINUTE, 7.2); + cache.append(4 * ONE_MINUTE, 6.9); + cache.append(6 * ONE_MINUTE, 7.1); + cache.append(9 * ONE_MINUTE, 7.4); + cache.append(10 * ONE_MINUTE, 7.9); + cache.append(13 * ONE_MINUTE, 8.1); + cache.append(14 * ONE_MINUTE, 7.8); + cache.append(17 * ONE_MINUTE, 7.5); + + assert_eq!(cache.collect(18 * ONE_MINUTE), Err(CacheError::NotReady)); + } + + #[test] + fn test_cache_collect() { + let mut cache = IntervalCache::default(); + + for i in 0..8 { + cache.append(i * FIVE_MINUTES, 6.5); + } + + assert_eq!( + cache.collect(8 * FIVE_MINUTES), + Ok(( + vec![-8.0, -7.0, -6.0, -5.0, -4.0, -3.0, -2.0, -1.0], + vec![6.5, 6.5, 6.5, 6.5, 6.5, 6.5, 6.5, 6.5] + )) + ); + } +} diff --git a/src/treasury/ft.rs b/src/treasury/ft.rs new file mode 100644 index 0000000..8c5800b --- /dev/null +++ b/src/treasury/ft.rs @@ -0,0 +1,21 @@ +use crate::*; + +pub const REF_DEPOSIT_ACTION: &'static str = ""; + +#[ext_contract(ext_ft)] +pub trait Ft { + #[payable] + fn ft_transfer_call( + &mut self, + receiver_id: AccountId, + amount: U128, + memo: Option, + msg: String, + ) -> Promise; + + #[payable] + fn near_deposit(&mut self); + + #[payable] + fn near_withdraw(&mut self, amount: U128); +} diff --git a/src/treasury/gas.rs b/src/treasury/gas.rs new file mode 100644 index 0000000..aab3a66 --- /dev/null +++ b/src/treasury/gas.rs @@ -0,0 +1,16 @@ +use near_sdk::Gas; + +pub const GAS_FOR_GET_DEPOSITS: Gas = Gas(13_000_000_000_000); +pub const GAS_FOR_FT_TRANSFER_CALL: Gas = Gas(45_000_000_000_000); +pub const GAS_FOR_ADD_LIQUIDITY: Gas = Gas(20_000_000_000_000); +pub const GAS_FOR_REMOVE_LIQUIDITY: Gas = Gas(17_000_000_000_000); +pub const GAS_FOR_WITHDRAW: Gas = Gas(60_000_000_000_000); +pub const GAS_FOR_FINISH_BURNING: Gas = Gas(10_000_000_000_000); +pub const GAS_FOR_HANDLE_RESERVE: Gas = Gas(13_000_000_000_000); +#[cfg(not(feature = "mainnet"))] +pub const GAS_FOR_NEAR_DEPOSIT: Gas = Gas(25_000_000_000_000); +pub const GAS_FOR_NEAR_WITHDRAW: Gas = Gas(25_000_000_000_000); +#[cfg(not(feature = "mainnet"))] +pub const GAS_FOR_SWAP: Gas = Gas(30_000_000_000_000); +pub const GAS_FOR_HANDLE_EXCHANGE_RATE: Gas = Gas(15_000_000_000_000); +pub const GAS_SURPLUS: Gas = Gas(10_000_000_000_000); diff --git a/src/treasury/mod.rs b/src/treasury/mod.rs new file mode 100644 index 0000000..4a34394 --- /dev/null +++ b/src/treasury/mod.rs @@ -0,0 +1,11 @@ +mod balance_stable_pool; +mod balance_treasury; +mod cache; +mod ft; +mod gas; +mod pool; +mod ref_finance; +mod transfer_stable_liquidity; +mod treasury; + +pub use treasury::TreasuryData; diff --git a/src/treasury/pool.rs b/src/treasury/pool.rs new file mode 100644 index 0000000..28cc126 --- /dev/null +++ b/src/treasury/pool.rs @@ -0,0 +1,111 @@ +use crate::*; + +pub(super) const USDT_DECIMALS: u8 = 6; + +struct PoolsConfig { + pub ref_address: &'static str, + pub pools: &'static [(u64, &'static [&'static (&'static str, u8)])], +} + +const CONFIG: PoolsConfig = if cfg!(feature = "mainnet") { + PoolsConfig { + ref_address: "v2.ref-finance.near", + pools: &[( + 3020, + &[ + &("usn", USN_DECIMALS), + &( + "dac17f958d2ee523a2206206994597c13d831ec7.factory.bridge.near", + USDT_DECIMALS, + ), + ], + )], + } +} else if cfg!(feature = "testnet") { + PoolsConfig { + ref_address: "ref-finance-101.testnet", + pools: &[( + 356, + &[ + &("usdn.testnet", USN_DECIMALS), + &("usdt.fakes.testnet", USDT_DECIMALS), + ], + )], + } +} else { + PoolsConfig { + ref_address: "ref.test.near", + pools: &[ + ( + 0, + &[ + &("usn.test.near", USN_DECIMALS), + &("usdt.test.near", USDT_DECIMALS), + ], + ), + ( + 1, + &[ + &("usn.test.near", USN_DECIMALS), + &("usdt.test.near", USDT_DECIMALS), + ], + ), + ], + } +}; + +#[near_bindgen] +impl Contract { + pub fn pools(&self) -> Vec { + CONFIG.pools.iter().map(|&(pool_id, _)| pool_id).collect() + } +} + +pub struct Pool { + pub ref_id: AccountId, + pub id: u64, + pub tokens: Vec, + pub decimals: Vec, +} + +impl Pool { + pub fn from_config_with_assert(pool_id: u64) -> Self { + CONFIG + .pools + .iter() + .find_map(|&(id, tokens)| { + if pool_id == id { + Some(Self { + ref_id: CONFIG.ref_address.parse().unwrap(), + id: pool_id, + tokens: tokens.iter().map(|t| t.0.parse().unwrap()).collect(), + decimals: tokens.iter().map(|t| t.1).collect(), + }) + } else { + None + } + }) + .unwrap_or_else(|| env::panic_str(&format!("pool_id {} is not allowed", pool_id))) + } + + /// Extends the whole part of the amount (the left part to the decimal point) + /// into the token amounts considering decimal precision of each token. + pub fn extend_decimals( + &self, + whole_amount: u128, + ) -> impl Iterator + '_ + Clone { + self.tokens.iter().zip( + self.decimals + .iter() + .map(move |decimals| extend_decimals(whole_amount, *decimals)), + ) + } +} + +pub fn extend_decimals(whole: u128, decimals: u8) -> u128 { + whole * 10u128.pow(decimals as u32) +} + +pub fn remove_decimals(amount: u128, decimals: u8) -> u128 { + amount / 10u128.pow(decimals as u32) +} diff --git a/src/treasury/ref_finance.rs b/src/treasury/ref_finance.rs new file mode 100644 index 0000000..cd968dc --- /dev/null +++ b/src/treasury/ref_finance.rs @@ -0,0 +1,60 @@ +use crate::*; + +#[derive(Serialize, Deserialize, Debug)] +#[serde(crate = "near_sdk::serde")] +pub struct StablePoolInfo { + /// List of tokens in the pool. + pub token_account_ids: Vec, + pub decimals: Vec, + /// backend tokens. + pub amounts: Vec, + /// backend tokens in comparable precision + pub c_amounts: Vec, + /// Fee charged for swap. + pub total_fee: u32, + /// Total number of shares. + pub shares_total_supply: U128, + pub amp: u64, +} + +/// Single swap action. +#[derive(Serialize, Deserialize)] +#[serde(crate = "near_sdk::serde")] +pub struct SwapAction { + /// Pool which should be used for swapping. + pub pool_id: u64, + /// Token to swap from. + pub token_in: AccountId, + /// Amount to exchange. + /// If amount_in is None, it will take amount_out from previous step. + /// Will fail if amount_in is None on the first step. + pub amount_in: Option, + /// Token to swap into. + pub token_out: AccountId, + /// Required minimum amount of token_out. + pub min_amount_out: U128, +} + +#[ext_contract(ext_ref_finance)] +trait RefFinance { + fn get_stable_pool(&self, pool_id: u64) -> StablePoolInfo; + + fn get_deposits(&self, account_id: AccountId) -> HashMap; + + #[payable] + fn add_stable_liquidity(&mut self, pool_id: u64, amounts: Vec, min_shares: U128) -> U128; + + #[payable] + fn remove_liquidity_by_tokens( + &mut self, + pool_id: u64, + amounts: Vec, + max_burn_shares: U128, + ) -> U128; + + #[payable] + fn withdraw(&mut self, token_id: AccountId, amount: U128, unregister: Option); + + #[payable] + fn swap(&mut self, actions: Vec, referral_id: Option) -> U128; +} diff --git a/src/treasury/transfer_stable_liquidity.rs b/src/treasury/transfer_stable_liquidity.rs new file mode 100644 index 0000000..6d36c97 --- /dev/null +++ b/src/treasury/transfer_stable_liquidity.rs @@ -0,0 +1,254 @@ +use std::collections::HashMap; + +use crate::*; + +use super::ft::*; +use super::gas::*; +use super::pool::Pool; +use super::ref_finance::*; + +use near_sdk::{require, ONE_YOCTO}; + +#[near_bindgen] +impl Contract { + /// Transfers liquidity of different tokens to ref.finance on behalf of "usn". + /// Mints necessary amount of USN. + /// + /// * `whole_amount` - token amount WITHOUT decimals, e.g. "1000" means $1000. + /// + /// # Algorithm + /// + /// Step 1. `TOKEN -> REF`: ft_transfer_call to ref.finance contract + /// on behalf of "usn" account. + /// Step 2. `USN -> REF`: If token transfer successful, then + /// * mint as much USN as successfully transferred tokens, + /// * internal_transfer_call of minted USN to ref.finance contract. + /// Step 3. Check balances, ignoring step 1 & 2. It allows to repeat adding liquidity + /// next time with full ref.finance deposits (transfers would fail in this case). + /// Step 4. `REF -> POOL`: add_stable_liquidity to the TOKENS/USN stable pool filling it + /// from usn deposit. + #[payable] + pub fn transfer_stable_liquidity(&mut self, pool_id: u64, whole_amount: U128) -> Promise { + self.assert_owner(); + + let pool = Pool::from_config_with_assert(pool_id); + + // 1 yoctoNEAR for each ft_transfer_call (except of the internal transfer). + // More NEARs could be required for add_stable_liquidity(). + let transfer_deposit = pool.tokens.len() as u128 - 1; + require!( + env::attached_deposit() > transfer_deposit, + &format!( + "Requires attached deposit more than {} yoctoNEAR", + transfer_deposit + ), + ); + + require!( + whole_amount.0 > NO_DEPOSIT, + "The token amount must be not zero" + ); + + let usn_id = env::current_account_id(); + + ext_ref_finance::get_deposits( + usn_id, + pool.ref_id.clone(), + NO_DEPOSIT, + GAS_FOR_GET_DEPOSITS, + ) + .then(ext_self::handle_start_transferring( + pool.id, + whole_amount, + env::current_account_id(), + env::attached_deposit(), + GAS_FOR_FT_TRANSFER_CALL * pool.tokens.len() as u64 + + GAS_FOR_GET_DEPOSITS + + GAS_FOR_ADD_LIQUIDITY + + GAS_FOR_HANDLE_RESERVE + + GAS_SURPLUS * 3, + )) + } +} + +#[ext_contract(ext_self)] +trait RefFinanceHandler { + #[private] + #[payable] + fn handle_start_transferring( + &mut self, + pool_id: u64, + whole_amount: U128, + #[callback] deposits: HashMap, + ) -> Promise; + + #[private] + #[payable] + fn handle_deposit_then_add_liquidity( + &mut self, + pool_id: u64, + whole_amount: U128, + #[callback] deposits: HashMap, + ); + + #[private] + fn handle_reserve(&mut self, amounts: HashMap); +} + +trait RefFinanceHandler { + fn handle_start_transferring( + &mut self, + pool_id: u64, + whole_amount: U128, + deposits: HashMap, + ) -> Promise; + + fn handle_deposit_then_add_liquidity( + &mut self, + pool_id: u64, + whole_amount: U128, + deposits: HashMap, + ); + + fn handle_reserve(&mut self, amounts: HashMap); +} + +#[near_bindgen] +impl RefFinanceHandler for Contract { + #[private] + #[payable] + fn handle_start_transferring( + &mut self, + pool_id: u64, + whole_amount: U128, + #[callback] deposits: HashMap, + ) -> Promise { + let pool = Pool::from_config_with_assert(pool_id); + + let tokens = pool + // Convert the whole decimal part to a full number for each token. + .extend_decimals(whole_amount.into()) + // Find out how much to deposit yet. + .map(|(token_id, amount)| { + let deposit = deposits.get(&token_id).unwrap_or(&U128::from(0u128)).0; + (token_id, amount.saturating_sub(deposit)) + }) + // Keep non-empty values. + .filter(|&(_, amount)| amount != 0u128); + + // Create many promises for each transfer, like USDT -> ref-finance. + let maybe_transfers = tokens + .map(|(token_id, amount)| -> Promise { + let usn_id = env::current_account_id(); + if token_id != &usn_id { + ext_ft::ft_transfer_call( + pool.ref_id.clone(), + amount.into(), + None, + REF_DEPOSIT_ACTION.to_string(), + token_id.clone(), + ONE_YOCTO, + GAS_FOR_FT_TRANSFER_CALL, + ) + } else { + let usn_balance = self.token.internal_unwrap_balance_of(&usn_id); + + // Mint necessary USN amount. + if usn_balance < amount { + let yet_to_mint = amount - usn_balance; + self.token.internal_deposit(&usn_id, yet_to_mint); + event::emit::ft_mint(&usn_id, yet_to_mint, None); + } + + self.token.internal_transfer_call( + &usn_id, + &pool.ref_id.clone(), + amount, + GAS_FOR_FT_TRANSFER_CALL, + None, + REF_DEPOSIT_ACTION.to_string(), + ) + } + }) + // Chain all promises together. + .reduce(|acc, promise| acc.and(promise)); + + let get_deposits = ext_ref_finance::get_deposits( + env::current_account_id(), + pool.ref_id.clone(), + NO_DEPOSIT, + GAS_FOR_GET_DEPOSITS, + ); + + let add_liquidity = ext_self::handle_deposit_then_add_liquidity( + pool.id, + whole_amount, + env::current_account_id(), + env::attached_deposit() - ONE_YOCTO * (pool.tokens.len() as u128 - 1), + GAS_FOR_ADD_LIQUIDITY + GAS_SURPLUS * 2 + GAS_FOR_HANDLE_RESERVE, + ); + + if let Some(transfers) = maybe_transfers { + transfers.then(get_deposits).then(add_liquidity) + } else { + get_deposits.then(add_liquidity) + } + } + + #[private] + #[payable] + fn handle_deposit_then_add_liquidity( + &mut self, + pool_id: u64, + whole_amount: U128, + #[callback] deposits: HashMap, + ) { + let pool = Pool::from_config_with_assert(pool_id); + let amounts = pool.extend_decimals(whole_amount.into()); + + // All deposits must have enough of liquidity. + for (token_id, amount) in amounts.clone() { + let deposit = deposits.get(&token_id).unwrap_or(&U128::from(0u128)).0; + require!( + deposit >= amount, + &format!("Not enough {} deposit: {} < {}", token_id, deposit, amount) + ); + } + + let min_shares = NO_DEPOSIT.into(); + + ext_ref_finance::add_stable_liquidity( + pool.id, + amounts.clone().map(|(_, amount)| amount.into()).collect(), + min_shares, + pool.ref_id.clone(), + env::attached_deposit(), + GAS_FOR_ADD_LIQUIDITY, + ) + .as_return() + .then(ext_self::handle_reserve( + amounts + .map(|(token_id, amount)| (token_id.clone(), U128(amount))) + .collect::>(), + env::current_account_id(), + NO_DEPOSIT, + GAS_FOR_HANDLE_RESERVE, + )); + } + + #[private] + fn handle_reserve(&mut self, amounts: HashMap) { + let mut treasury = self.treasury.take().expect("Valid treasury"); + for (account_id, amount) in amounts { + // Exclude the current token. + if account_id == env::current_account_id() { + continue; + } + let prev_amount = *treasury.reserve.get(&account_id).unwrap_or(&U128(0)); + treasury + .reserve + .insert(account_id, U128(prev_amount.0 + amount.0)); + } + self.treasury.replace(&treasury); + } +} diff --git a/src/treasury/treasury.rs b/src/treasury/treasury.rs new file mode 100644 index 0000000..4e3ec47 --- /dev/null +++ b/src/treasury/treasury.rs @@ -0,0 +1,22 @@ +use std::collections::HashMap; + +use crate::*; + +use super::cache::IntervalCache; + +#[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)] +#[cfg_attr(test, derive(Debug, PartialEq))] +#[serde(crate = "near_sdk::serde")] +pub struct TreasuryData { + pub reserve: HashMap, + pub cache: IntervalCache, +} + +impl Default for TreasuryData { + fn default() -> Self { + Self { + reserve: HashMap::new(), + cache: IntervalCache::default(), + } + } +} diff --git a/tests/price_oracle.wasm b/tests/price_oracle.wasm new file mode 100755 index 0000000000000000000000000000000000000000..95f47afcf5d67ed2279a3ee9b1af09f1532d7f77 GIT binary patch literal 197498 zcmeFa3!q(9dG9+P>$TTfduN60Kp=_CwMJepG4oJNZ<|=3ZryRsIF5SFy>q{@+wR`K%XoYY2c?%2I~ z%O#gwaW%h}Um7jdgQdGJf9Z~`JC9m^#m(TX*fcV*X3@%XeIP^=?ddVeQ zwvFCD^GANvJ?~z#W&71znUdXC@7&=gq<-a=9hYAcP3!fxU2nd6_s?u_4_n)>cxmN! z!r%VLS?=-Fl{>F^+2y;oZoY(>-n}(iu130{aQ9`*@QEtwgd%{CPEyHqD0#`2-C)?i zZ;wtGeq^nz&^u2bez4_|-Irgn!@nA6#G!u8*qUH^`xUR)e909%cJJh6hmpb9sy}n} z4&VBg?c1Z1)%)tP6=`Y5uAd3SeahH65Y)D<(J5-=jIkBATzcu|ZChWl`DZWRec9%p zxqAC{jRq=q?>ysJ-l>ASQaznI_N_~|Zr{3lt2%R|ACFRB%hRu`xjeMDbL+0Fx9{Es z8evsOqXikbXKscog+^?~(FOPX?9R)fmsNta8#qeRBC?sDDvMrr#Wh=9;gV2z*_K^4 z0;85CQ1s=OZhW?`tkH|8pZL{RA=?m;<$5a#-G)v_WOf4 zUft>QC+dv<^Yl(9S?tdg4{lE{d?r_oR^sV8kh(7$E{_1`| z9z?4e1@8{XUIGs|U2XdiA=_|D-xU)austXNo`eQ*SgH zt)$gz4NgC!R!i%RW@}=i-DphJ>XT_&Yt*Ns)hFW@^SJTtF*U#$dXf1st zF#!Ispj^Fr%?~8e6u7XmB$;}~+SO|e{J6883r0ibzUuND|A_wWbbg@I`O*JmwH&IV z26lr*X8jadNsh&gbS1N1eSA zveh+vce1>ExBB2Cg6hgEcKX`8qK_sW*Wcz#B&qI6+MBJ3&0BX|n#P^Y=&mhSqI!01 zO_PaNgRea9{CWJI_*de$#FzeBd{2CRdSm+f^tI`}^se;1@n0v8BwtScIr*35Z<22( zk0!56e>?qP`a9|DMVJ5g%U-bejq&T_FDBQ=A4uoo&!;!U|B&oCkpA5N_VO3*kN?*z z|MzSD+sn3W`|1DllHHrP|J1IZxc2|}*`K`PMX$JU$EK@aa@C7>Ui|aFk-j=U68}T| zkMXzTN8^8r|2h7b__6r^ivREUU*qq@-;Mt*emtH_u1l^@Zb zye7Fhd2RB#(<^o{AQ=`W}6NZ*;>nI1~tm;QQs zNBXKZZ!TC;f2x`{~!xucv>V{!#kJ>7S&ZOTU=@Mf#=m!SpNXU!`A7 zA4&fveK`Gt^fT%G>7S=xNZaqew|zK$I8HI{u8sFReU3j-o^2Z>YwR-F=>BH$TG#=Z zl|-E^{-LzhPqQRXpB1&TBujrR?Qz$d<)0O^`Q6tao{M_Fp_ck_##En`L|K&aQ|l%j z3L+~|{dis4Iy;TJaYxT7V^pFSI^`&Q|ctC_^LdZ29e`m$B} zp{?P@*A6wVrq}xcW>M$W$1p_RU{J36VXy))kGzHnbVEEYV1{9NXEKkd;t`^XDnu2D zsFEypL=|U=h$=QB5mDWLJuo?YDfwGyw+)qAs!{93cTBzA>7*CmmVrH6XI_aVKh zm&$pKIv16K20#lzlTXh&*_Y-Y`bCo>JtP2f#Y>-6pqPG4ia_%wAhM))2TTb3pNQjR zuhBaa_x#C7m&|F(c$uC&>L-w`esr6uadQ4- zog$<&G%?$UsPnzE1DftglA3&^2>@EsDUkcno2$r`Iyh`4zv93x>OD}ccQKerHs;fL zt@loeNA;n*oGH2a5DhYqH`rvPE0^*+7x71=2Mi!fG8!QaAu|n3h~#W0$?qp9?fh~a z*8`FCO5AJOnNv-Czb?E9L0LlQ!dr?Qaa7dE>Y$c(>kQVkRn`C_5{3yVk$?iF{bs;Z z6C!BLQgkl3;e^tvh>3rF)6Kyo!fgOwGq3uES3$CN4>j+ zvaH7V^Z2=RVb@R{^JYqTxb{beY8xj5bfq@9uOYzuO##HD1iJ&yZDJ=F-DC}}s8`HU z=QFjmNhqtZ6u?v6;R(KCT;Z=!(;76zKdr1OqKUH>bOJ6=Hxe)t5=Fej|IL8gC~FCs z`A^MGrPxx57`6%5Wi4w+bk+n|Yh*%=){PRWQ1=wo^vD1^O$OVo7jJW`-sw9Uw0%FD zX7k76s|KyS?HcP!s4Uu8GXw54-I%qrrh)34=;ZAePHL`f$iA;ue*Z80*4Lx+0MuVT zcQVa7dGmrvX0~hrS6tRvJ-p0|s)Co=4R7KO9;{W^Ju-1wRl@N=jvU9#z$tvRrV*k;bR`6 zBYR(B`eY0sog7<6c8Ym-jjZvDS+erS%*TV8oJj(93x0cbtyVYTUFA7%e~F{SOD%?B zELG9;%u&$TjgmPULWO(?hQkDM%g{nI5nNj{uB+winNu2Pazzkub47594;jBv^i0(I zU883+IBNL|9hI1%PXm`O1c+26bYLeNaArqr}9=`e!W3ii8oh>a^Kagt)p+!$T~#_(D-w&d>D_tI;voU@v< zY>>MDRm3R)YT}jaSy0LtxAp6K#iVM>&u^pPW(nzr%pfVTh8aRC_*#To^HW@k6_^-l zNgG0{BOtU35>isp&?#LZsp!Tad1NALi2KdT!RjsqR24&COyg!SCs8i(8fIiJa^uy% z&ZbTDQya)LqN_xt4E~Lj&FGZsu1sw6Tbq4lzZA-3^)mV+U=t_db(vS1 z$R^s)2Iz#lql?}rG%ZdJdIY#J+SKGdk>fsl6BtqY_Kw;4w4rjF9K8rlxL3U*13ltkdd#RF+e{nL1O!k4 zI&;)zt$?AR>E=zSO>!~Tv`XGp^X_hWyz{hOAa8lT7!;CT=KnjPF6eXxx~24nM}btt zfpbIEyoz)JkoA0w{>cdp1@-gn$o~l!bA>K4=BGiK>tR@(57oG>JwnpO7~h#d{4tpJyK!ZFbT7k909&8VyA-}bM59X>$9 z<=?WGKpfL83`F@W=ME#r)86lhNC)*v3DM>PP13-lzM+5RmvPqv0l)!F1<+Wl29Kxg zdKZh%d+KrTu)2{Bz~i9>9;`)M5bju)N=?9c>AJLccA8O`5g}$spEUNVV+B&y84DT= zN*uw5SIW^@6L3i0o$Y-}t%%~+CYidnuIOC-T4cArP|LirreBv3sJ3j8hiGIxGbj4>>6&E zntJDTBg+A(mWmA}$~EBvM8gET6fw+wc)*+KWGZAn-8SWh*-9s zgAl-1KYwzHAC&SEWOM_EFzfVw^9D_*0ZZ!$zal7icqlSzuh-n`=*6Met=rIq)J;88 zkSp1Udj5pkA50z`@cgO}ksQW3y|=D0qqLp>on#R&w)3x;RBB70CEPyaT+D>F4K3{s z@D=m7@132h*ZTc_y|3Fha@(qBnILOrpu=}>_luH0wb`77-N#IZPjG%L-B=Z@Z#xAe8Z;az_;P? zH+Z~cWDHd38R!QEF@QU0ml_|p`lNm>d z$vSF?DOB{GHqv#;MJ%}#F8oE_g|~$gy0(s_85ob$nfjQJe8wq2Adl;VhEa3F?VETu zs|HZi2ctliL&r1?4(AVuV1tdPWYTGetezoj$yj8$t_uyjj35>Pxg)kz^`7g&2D-cn z-sWtk4*C-Gt1t13T*c%P776nVwBd3>baeQrllyE3@5aR@x6*-G(;JRPG3U5OH&~+! zNGidXO`QY3fn+)N8uDH9hU`khkX7fld39V#s3U__MBx5y&pJy)a|?~KQe**88U05g z`&DibD{K&*u`?;dzhW#2;}1o%&X(=`Ot}z?5u3PDBXpeHu9mDKmpzi$3LO7HucBdm zSzGBv72trlwY->~rh9)NBUuZlg@GD(z7;PPhjH%RP!xtj{_iIipq?M&wO&>cm;HZ&**Ub1ve!5hp z8;s_}W{atHvn3pqvvq=-+%gncjg>5diB~NeCH!7e=U7ZY#DPXdr=C{7GzK5|`wQSB zJQ<>Eq!*DrEnU|9dYCa(B8GybvZP=r#UYDjOgKp^R0?g6NA37h=I~1xP@+UXF@74Q ztQKON!)e@L87Ye(;bQP{ey!}GD1Z6v09t@sh%4^7O5~m7*Ip%F+Lomf3h>lpcVar= z@$I*RsCEi>lrbdo9ilG17g2Hj@q z8Bt`COpPN%=unLl7|3I~AzFv5=3T7`$GuJXh01vji5-=W`NUgZy2X+OW? z*D9rIi)J)Fg8pDWi&zpEUl%x0Fot;YfVo+ltjO=R6eFUEB-1fCw8_%zq#2^3#=e^l z15JC88h`XI)#!fTYkbkg}CxEsfRQ{Xk_qk7X3&Bvm)reCaTwx72M11*N1QaTDP6QNz#O6 z*&=(d42S2Zx%Ig$nmO>N7`vWAC0Uy7nLf z&V1j8qa6dH$-DE1{t0x9~$Al-g7(jvJ7gZ2g_UQk}?x3O3U!4PXJL1w5C%$Q+t94d|%lO9&$fAt}E4>>$do!;#m^b8-IY$3S@RUL>C& zMNa4Y4pWk&PSg|i1#|#a8iyihg_HjJ-eZOJ?C(3MWc5Ay|Jdqd%3qdoY|aOo1Dp9NXZ)Y`AdW%3uKTbEQMc*IV7_bCe8d{{j(n7V~IUsA&7)0y*Lk$*#LZyYyH~FMh z0brH+XDW$eb1BT-(f|-7fQ+YQs1Pp*mfoBQ3(>+mh3CaIJOezkcyXhio?=+)$G&|5 z-n&T;wEW(Cr8V&3)lG??I%^2=-n2~ZLkz`^7=tbLM1LKKwx}fB4;1lWP^64vw*XoK zs#s^5A-*RGis`}{__}ljtBaY8+;a?(ByaGisYOb+(0o>Mjv%4}K?G;uB}6P?W-K%} z{(h<&vJAf?%h1PelvM2QseD$l?~opO$x78Z-ILJiyKCrmt3x&d46Agdvs|UD_8it4 zkukuqcJ`SG&_9#qGwSbG8@v`TC3rL!Azvi6f$Yh{LrUIa@UU335Hxe~(tREpU{NzR zRHdX5r?P8M%j}$E>-6W)&gsLb$D=^xA?H|`Ii1HF>@ha=)3{l$8&XCZd1E*EA_{pO z>Q69e)|xf!(Z6^k4O$Y(PeAf%O`GB*OXts+GPoC+HRi-m*0RNsvrLm!nV;z(yGKW{VrE44A4og zOysa86o8-N$^pNGtIXcO=H}Y1>}u0T)@J4LNg;jt;zL_*Lz~K$98y;6A>y9h$`}vC zOJ6x|j5x71C`e;;5Sxs!tr$-p;u9B#_(X#k(k&SI&GFLx{2WvI8sOJ6;1GLrFfM~Jo~HO4=T1JYt3+F1tqoeTEl$R>@wP>)YFiL4lx@*+w#BKIWjq@! z1teh$q3UiOEwL+3dW;Qrz23d@C(O3M7+Zli#81{wQtS_A9F!oU!u_9 z*A}+#u<7d!U;GFddes1no*)Ow#(pJ>tg^Gy6{LN~5(&r-gg`L*ZHi?QdCe3t}_s;W6OgEZ_HRh!l>F(Bt} zl694Gz(ty9ms}n5%aRpov+mYP-D-m#sLw{ADH#aVl;U5!ragCY30t>N{_IFgtJD$^ z0U3XNtWg#lYQEc%nmEbmp9I3;YM{j#i&Mn;nI(EOe2=KL$@*a|*;}+J1ttWB07LH= zlpn#2i-Bx^6BAI=B2L^mq-d9UZmKLWOW~?UjjQh}T?AoPt{kT%o z_P&9dfBkUiNYSY0xp0z2l0rO(4n~4Gjwpnw@UG2!KSp$gV2)Z_I~tr)lSM=aV(~*{ z3u|fw*)@h8D8`s~U#2)j<~D)mT|!H8i0R1aVlXzK)O7)+-IainX4VgS;3CGx2Afp`dQX+T>BH9`lOMV1jhMhJw+2V!Ubzkp>* zmTdU{f|Yq}xXK~Pl>ig>-mH#54r_*3pu%+Og_Af`#qg>`_#zw3d1qZxb6d&-yh}R0 zx2ox=bACZ~v}BXIElX_8R)Mk6DGd|JlW$6J5TaBy&2py)v1+gmJ7DBXgoTE7h!&)z zv1yNo;RK;p!HKCVaFXUySsY++XlDJMLH!^HG>~id98B{e6s_N$w+bwwnLU=0DwZf7 z!cyY5;V0E?_^Q+g{hA1g)O`I86NGkjN@b=?%pHmibs}SCNUW8U2g1;z7qAcvQGyMZ ztI&zg=7Be-7 zK1R9N)TAq!yXw>c_P_7sJXN%}b`jcJ`#qz*wMV19Cq82UgSL0 zGq&P;H>3sT$c9v%qo;aEN1dg=jLQYfYL4FVh(81&vy__iKnhEGu5RH z_S7<2a?MdB;P0n3Ek0FF-Z)%tU2&8N#v=Eu};f&%(sj)e^2Y@T-lvG|~HIGeWF2rS?+p1iCdF zHelt`uJYSe85`V^uJ#fsVk4)7YJP>=?4pBF@|H5z5)v5oIL_jA(NdT5m%o&BA*z#; z#cU+op37Dbo=#}}WL>1qHnNJfIY@$-j8Gj2#ucDWxT|j1)+I4*DT^EjFrDB3YDS%( z(tC#okE0*v7b5BB6-w#UIdn(nOq4Ir?|qFLI>9wWxotXEC6<7|vYZKLr*uA7izmW{ z#PS3pDAha|R?hJc{0f+azj+-NG$W?~6zEt9LVBcmHS+WtY4=v%ysB?I6e!<-MWI^c zCfPoz8q0!UnGz7!${%9^D7|W1zm;yZ^e$_O{`kGp`Aqp`{`X@4`y&6l$^V{bzs*_y z$5yf!9SXSxZU-$)TUvWId!akogmg8VBevO7Trc%YY=F!;?V7gz;v7ZsLgLdCz5%AR z?R+jryq0suaVDnOv$_aeE7trpMI~teCXI1e1TjTZ$xXdS(>hQ@7iKNA+^*x;9~fl& zof_aWEzC0kQ`&b;Z@DxpmJ3FQ5-F9p<^rUa35&s_BU_+K9lL~S01`xZ%60YGzg8sc zfJdPSy44|2Ze6!Fn?Lq$=*M2}eO$CC#64st#D8*49d^s91O<}{y{{^)r-C1>p0Fn`=A{|NB1hvDi7n#Cm^6-b)4hW|>S=)P8KyXhh z^F+fGStn0*ZNer6KQwM|dnG}E7sy|3G8FXXE3|)no&bYwu${-qKps42k_ZXAK%BEK z&Y|^HtfBHlTIsqd>dUo+zPZAGTNkzZQ--gX7Pw3DlZCsiV;fiEtaFfcspO1kMZX7p zMki-FFKa!?S-m%fA+Cr2>1KoCeme1B{dRNdjI%PfVTe$X?>%K2O{}GV`DW2tC@*1s zAnTq*c|s_QBz0Y}<0H!Wsht&_O!+FA=vF?ZH4BX)oAeuo=~U7bYTLjp5_4guZRBT) z71LP$qvg(<>f0RuI5rZQdFUTJits|LL05?+`zQ^G^4UFz4Xc8)&Fy=p(5+0sU} za5SV;`&vqv3pG)wc2ntAUJ3@=TfLqzuc>w_JJsG%pm$VFb`Y?m$`RVZe>2o&9W><- zZY0&`;l`plhMN#S()fj&NVp+>38IPoaVmyK3u(m#TE-E-bSPX|3dga6Xb4Op7d7X_ z?H>-uAQD&Xc@coJ*kws89;E1vGi?Ieb~G+3U=edjg$l<`HxiBn;cRdfYrA91H4vQ9vg4opHBQV2&*yaRlaFH`%HK}IC(m-;KY}X9>HR!be%8|AfC;pM~57E z|F4BG>Ea(S=$x)XmYtAwtAM$DY97-8;i!GfZR}m z-S2Oq6TxWmSBlAQgo7SKpmJdvy~Ib4kfb`T3Vg^8iP^to`GdhGOyqG?ZNSLefKkN; z48c5yA?X6qMrQ?Z00NB259Voi>1#wwQRl%foqMZJk!)Q2Zx-RkO`Q;7ep$}f zM7z_SoLbUbidus8&xq_$+Jv(==<2Lw8t7dD2tYCZ7L;k2U15yL*}&@%zRZnbW$I=-~F5r-nao89~ zO)zZBIywH4edoy0(KzKgGhfbRS#IQU{GB~`44rZIibh5{g*h0E?B?S{BO*xza^Ep@ z*44^YpgNehpfzL1BpgwT%#)x~s~-xj&LcLI_;I#%*Me=aMf5n^x^=;}*x-7cZS7yM zEiA+1Z0pG1d-|G(FU-;7Z0n%~+afG;oNaw>!M3nNkF%}&7HkV$bewIyf5EmC?LR(R zy>-F1OmiF;-S1nlEo@P7j`6INh@_G!69=rc3D(nGgjob@WB59aoW-5H;vwx4hX=BX zv?Hvvig2f8ETBLY6!Sp{E5eRYhoQ)CSzaM6Npb#732u8i7&TF02-y3FAEiP*WC+-s zz2B9|hwWNPafmuE9|G8`L*x~z32RRFtVHpes;-)*V83>$N}VP7Yn?E2Mw;_rg0_=o zg+Jnt%;%;+Rn(dG%Gnfkt@jZDr*obQ?W~wV0Z)FXi-yv-K%-xQ28256-dTgh)yl*8 z%{G*DyTbu0Bh=fMXY#HfF~g55XMR9VG9>dDo9Am9_7g?l z{ZATwpG}iyd3w_LJrA;dTCBgy1o8(3LdM^dE$T#u;1@@h?&Le2Tkgy$oWL^_SxDr~ z;|6kAIaRf1-ReW_;k+$zor|a_SjSV#l~p(ZjIT>Gm)6Kf7=BC0w|FXSF?^Dv1Hyk< z;PMWFR01))dKnC+A0M)-+3|9f&~VGU1+9u(0D;k$ z3sl+&G+QF0B){d2h_0Sd25fwvlU_QuL0_I2KZQ6s0Ocd7Bz4F|Hm}zrOzui!*Q&Hj z|Bw$tU%}1qd>Zryw}bVt*eM2Z0B;h(>wQ{aDAJ%7c+q3fp-Hpv#^a7&Fn=09T*x9w z?#>~1q>^sro)~rtTV!^!8E5oB6zxD1?Fvyql$t%0@r1d~2lH?yv#OOH^7DyYu!NwK z8HkrH_LuW~++l_jI{T}^Er%J___4zbyORh4Zrq`T6S)p8)Db}b&_aPgx94+^VTde@ zoL)%my{U79ChVBPm|q=Jh^0G0v`M=fbs8`1p;HR&G#ML~wMj6}M=SDubIf~jA|h?- z2sVd-(W=8I^-(qLa+b{eR+-}7$KA}4wIJuLtW(BGdUr{;F}XdhL8aiLXnUM}C=B(GN7nXk2?xv7cjT<@-CqdMop3Q>Cx3`CIr$^iq;k?cbSe6`^O4={zj6!o zhK06B9!o?=AVK+_22K#d3L0p70x-JC+SqRF>O#^&X^MV|GfhIn-#()0TBD}oykjvu zzSOrCIk=gpzktJHKoO@U`J0uzny<|t5)TF9^JBC@Wl#mDbU@!)CJCaaRfry*WTogq z!Z{?Aq6cwfq6axGU5#}RAvd_vQeM}1edstG{K=Ly5N{O%M9sR;WWjQ6O_Z?P^2Z8# z2^vHvtF#7h+m7lnc%vXHqajh*RyQ_RngfYPI~)?7AvrW3Hje3G$a;xc(}!4$6IwQv zkT+B7rm|_{4GZ97rwlCggazXHW1rg?jl%rIiTyNjaWQd6h9)jHli9MZ+~Gnfz6hEz z+eC|e;@fcA2{$s4yekuR{;ZWW%G@>ursMF87)L(|%%NX!D+TAav+7dEw2Ny8I#b=A zV~rT@8*wZ(5Bi?z*RUG-BmbHQ2aqr)C4i?IZKmP; z%QO$?U#9t2?EK5r!ItX$OD*c?XwOt#rtbX9q}gmH&5ku)w_en#Dnf zAjtq}a?GJ%utN?T;lMvG+#!c?PPTNUc3h(K4i?7WD%aTx>uhQ~{+QyX`3RVr zQiy2n3OR{z%w^E(%_74($Mv+qdg4sLaWiFsll6->bEa!%{bJ1+yDI{*@VKX4Gd*jD zquRznqi~6FVZEfcntLy@_mIhB-ji4wQTLmK7vH_~Foh znIl?f2sUsk#p8sD3G#^`$R{d-9C1?!7MTBh1hJDZl7Pq>EpwZBX6}$h7EmkR9WrHu zc+3zcRd)zggx-f$xo`$Sd`480b~i-^au#YqUWtN3cIJ`21bS`>j#qX4{Ni-bBsz*K-JzgK1A z;D8i1oi++kcEvRMG!RXbOA#R!dcBY)7siPY2;cf+*z_*PLCx+jLlhKZ_Jt23J@$sf zbA|mq-WV)Ohw5fEADCdMA>?7Er~t75Mp6W4I}cVQak*}+vFq>mO%f||m4L1%C5(^K zh~#lt#%|4$V8CZ=rEMk7zb}&cDDW;UoR9LNsW(V3?Y+Mg(FA*xKT^SfTfQd%YpJ`! zJ~G(Wo=X``>Pt|JlF?zAe<2zD!FqXwXEnwz1@9b%Dy5a*b#m&DNEA{jI1P&hJV*3A z$AFn1LCToV4n+QbD>_$ata`%69;oWr(21QlxjM<5TT6g=K2pRoEeQ(9sE>>2xFnj3j!S^^biJPm$nj&THk~Fg}Xugb* zp=x+e7SP?-OOCkcxCFjSL=rW-FPHODE^c%#hUVMsV5tf1YKwl{UdkK8J7!@ zXdy$tS&dEohk^S26N4zJU`V0Vp)6+(nH9dU3|#CjZ=k-flzy~Ym3|P)Q*WUD2MzuI zkcK|^?@L3!Rkw3D8^KwwDp5&)gso9EQV)r(7=4;-EdQ#=^428^?bxS5?V$DrWHm)E zh}G zdiU(hxI0)=w5SjBHSu}qVIs4$zfEN-kjlbLCqKDZ?$dryggv*b`E}Y5S zv=5qjC8}e9_zh@YXR$44WgRV6^Wvc$qOr5cve=@LN?M^8Y{=e+1qmX}WiKJgRDq;> zaRjvjvsRWU($2MH5e0!KPPFU-%PCM~xkwpK3LztRo?+8_*e3-XZr79jFldt!N>Z(| z*tm@31Jkvx?SCrbP(y1ZTABcEb9P{0r3~0t6!^tqaQgt==0S$4PY)xI`TkeLT`j-s z_4mx#s=kjDHOi8KeQcWJgS1{pJ6e?T8x2_?wU5#1gVGeTHLuQwLv<)?ypd1j`|mr9 zKj4=@azu@*#ty=B2Q|K&O(jg}mDvO>@`m>J)pC8{)=Xzu3W!yKi zZuqLV<|fzYGu_K>8o-j9psd^bmez5gQSj2_+(^!j+@|-lhK{<>p!W7BOl#bA@0(lf z+2VVF6tyK@V=f&rh&Ws_2j86+(mNsrbg%o%6z|=YHMen`Hq#*@$1AX9B3z=G}GI~*uB11k0M;HyK32>C2(Q=>A)&5MHoXBsf5)4{@BEO?r z5=e;8#InvdXp4ksI%^vV(X9Vc?&x6g93dV**r{U~Z09%z>!@q|V6|H+n{tEge2)eT zeLzrgJ^{PvBbqE6X`66x!+`$NqHF;mwK8_?&A;S*VNLj=7`-Gvi+RF z5tDD~_nImY;l6W^1qcJ#-oV(QLHm4&-@3&mG?UIQWn&-`+6WvJH+vr!8=7T7bQX3X z$OLtXVGxiaem?D(!cMYlBYrRqMJ4>Odd}BYX|6eYdKBd!W2eeQ2o&+y;^6KGD^y=jNuD(q>McZ_Tz@K6p=ge)N{K!}T?0vuV!R*4xHZAF7 zt^s@_m^hyW5b8U$lCfV83Qa1)V1|f4NBZ?>+QEib3Qf4qP5Uo%R0cr z1*gqAymTC1I>HM&FU>k7EP?s5n%m2t7%=1SuzXjIFmY9X42}&{~ zuCO}Moia=t2e}8X^NFJKiL&#IoF)QVypz8}-#Oq6{|EG2L0f{LsO9%n5m0>bbAJ`Z zbmkQ|Tkp+%LynZw@yLP7bQCSzS1m=HOyrM!O8xtz4{32Ce`Kfx_3ul<7u3*i`4@)j zh*qGW{FW-zpq)vk^fBu*Or}cZAbnw|6htB*8i8od=tK1IJr{;K!SG-^XZ+>L*r_#w7FKHgi<=TG;7OR5QM$3daVD zbAdB_1Hma!{CQgegnH}}gF?yEh+a!g%2K2YORd^@n9&@O2!>57ZuPa5KNO3P)0_^9 zCr5l)>dN#{qeLgQH8`J!ZGXD#?%t{El4E}8=&uo|8Lw@wsU zNs|&dqau>fiQo`HETNpP#9gt4(v{lo;-_ojd4gpWI*@3k9jHFq{)=-=nDSjBXC-JqMKdXpA6v}d^1?sI)*#>^S%_u|9CooxT|*TyeQ=fF^fj24qB_G7N`So}Rmsp-iO-oF%a9D17^*JQC;{ zYmslHa7A!NFjL~`8O%zO(YG+@znzz=e_K)3Coh|X=X`(&n6Z#qr2rN5>L^J@PArjG z@`i=vKo)rAV_j12d{F*;X2N$qrdb~C#mG{nMdvc@yeS^ulT-K7i?5JMh}PX6A^KI; zGSXcFwq9(@scT!#>m=?ZT8eH4Ks`Bl$f?;f5hnEkdKUAb*Jy3)Sc_58B* zRO{VAa10CJ?j){<_$T@FiG#^a6j(4b4U#2BKAQh(S;&fROPS=7>;@h zI7lFC?qlviixUg3}f4N2Z#&#ZmVp8dXJ1sn(jp$=b~z=LX$U>q*p z06 zWh~(>jYV%&pXnR3g8XAZZn;YVa@0))ayu7zs6fuJq^R1{JW4k~5dZ;ac4p9NA_blX zsu0opD0T<;(rrlKqhqcAIdY7i>GR?+k~l*mP%Kj89@aL;6{6#bZTQ3e&EZbJ;g9Tv zb`U(|m!*!QfC`t@*bJ;cD_WbSg~g^s3>wQI8U%o|+U%#?Mj-JqsGDplPEC#_RHDB9 zDE*Rfz-}EPC^Nvw8k@;prJa5{H%=(9?@jlJnQ+Px|C{|lU*77QO5-SjE+)WFpAWR4VcUw+ zb&~@nzliQrirEO1`3WuBkVEMEO*u{ zXWX7;C1oEp7}JMJkJ;%i}M69GR~U((rH%^N`Ywrox%uT8iUJ?vpV>63mI$ z_v^jAHT#xWVOHE#erHceaEK72Vhn?Iw~<7X;Nthm#?-7Y(~FDcC8bhCz#zG>=tj)T zz*P*Q9*KO)8zKs12VfF;`<6h;6|3r%6jBUV8G&&~A$6jK6wsR zTqjB)RuZx2*H~_3;wCH-fKM^L7Xfa$fV1smV5njHkVH~!#m6UlWGJ)M9IimRmX(XW zV*U##cG=J9Azn4oRT~8_FgqtQMn@htFY3hDDv_YNo!Sy0x5aLrplc|m$8tH?SgOmJ zsDFYZ%L;yiS$oX;s6~&0IMAcKW+N)^H6|P9{{<_a3cqWSfu*vFAa*42{Mojxr;Z9G z1p}ALWD-{h1!iJv5E-Y>`-y(42BPyk$5LV1Jwan$%2Q( zZL&5F5Qj02G(p60R+5&KmGj6HbJOm9N+Mp!lj^w4MTxk&vJybzb~ndEPSuh)j$oH` z9f9+&eEko8?UUd7{QDn{_$(unybL>LX0FCB_TgM@W=@{O*WQA*$m?#IZe@R2hlUU$%Uowmvb$X^Z=&+VZ<>rnUdzR8mV5$8$ZDC5WkI zC+NeFan|dfn62oal%3K)nGMHGQ!W37_1@~;AvX=Pc3GzY$QNZRCVO_+llEDRvUf_f z7)0F`&-Q*@E#SUR>KtD>{0Tgz*zYD!wWHXfv-e5W8$#t2S-ky~($81+IVj_dXfE!r zX22(?B@nwExY%~dXwm}SJ3YMEC}TGwE>Ief9bQ)|egUI&j7_;qS{i~;^V>f~&|KMP zM}vUs*#tT8wCpsjkj?RS3VDfrt7<%$A)Wq1CXIeuga!kTtt$cye+w<^M3rOwtPoYj zMvc+=YIIL_Nl%y#D3DmM7_B=21p>UlGDNtEEw*P2Q~&nCQU!bR+jSgD?^peNlru)a z$!2u9VAiX*#rndi1wad<#XjtglTOr5>ZYoV5MD_ zDa>CAYqwZb;IWW@(!w}$XCOaJ{+SjYeHC&EH4F^1Qk2d;D*wW8j;4WmbJ(cRa0;Ws z>HLa<8-)k=VMP0m*3f*|T-F`q`8kv$Vnm#p8XB2IT(spTRi2g^Z*l~HcypQO%|^ET zVE z?z_6IyvVzlu6=)hlDL?@7C{q&!vg{r795OP=R`3tvGFwq%k{Jzn zw8aI{82ZkvawOnqBzOA4<4T9eRl|5Z+2ipfkH-@|9#;?J5w!^(ZJSujlN5C@bE z;3mCzK=LOK#AR;gi%Ew=Hl3Z?CbD(uMtzg4Zw3nzPf^)*1ZS6t4ytoIB=kX?g%`S_ zaCyS4AKoIVDn{)ov4LOZQmwT;ZS==B3+%A0Z(gNd;H!+@qOx?aME>$9 z**aCx(xQefP}|Vp4u#jX-a>KeV@j5EO6URZ4AYu2d3f`+{6#)Zgz6xutJMpQbFJTz zr%-qyP!v3;USNe{_gw@l4DG(t1RufrL!N+t35b{TLwH=`!jU=cNX>HUe4H&iD7Oat zOIgbW0E~sG^b;A2auW1C12+g|K=?r@HHaQ%&_0GQ?zZs31z5U8)Nq+wII!J%!H^i9 zr-oL806nk+uZnwc7{Hv#u>7ugb`A447j<5@tf52HYxZIDWY5#BH2?SA&?@sD_eKyB ze)Y7CgVTR8h#lg2XOnp{T#&7DOd9I7JI5^SD2S zvLJoYjG^GaTLkCWLJ~SfB3KW?7xs$q1u+R33;hK(<^(p)SxU)0t2lv?&Km+W8iD)F z_LAi&r%#rn1|OV0sB|Rs@Z>=+oW968d3-obPTuLldeixM4s2oEjwZnmGBCl!7@rQX zCx-nwXTpwQDx_GL?hH`g<}tHoeR=rL~&2vn^tj|y1(X#t9J&{S8& zq;_gWgXNPHVlsbF3eNjwNYGZ7$E)1u3*dacDe1$qHAHM#H*fY$>yeyQ%fH3M8Voxc4bRGFakH{)il!h@Zs$ zu9l6Kcm(od2Ms8rmF<1zK%B&hI-v{q$cyWpcV9EOq53Kn4`aAL_VZj$Q=NR{L3 z-7D($zMj6<IkL_GS_19Q{r)f8mBig2GpsaOn)%J z!rqpwWz0)w8OiE&u9tEmPS8rG*+&^ajGwwfbR>F4#*&=&TqKi`6Iw%-Q^Kl9X~73k zFzobbmo#=yVh2RQ!v)~(2&%7(-gOB)RBDY$&748)V2ZbS_{p_OO1|xxRMv<5rW603L}i$@vgpD!oZp zI3Ub57B|5b##jbhnqkSKSy}Q>zZf>~7eav$DGom&5)2~~Dd-RrDSQe?9!P{?!*R7A z5d55r{jzk-?%E2H!iZHzXtMz}1)skXMZA@(v6o>(Z<^aP|GFK4{I% z?YV(fA-*b26cj;cVm}G|R@rDiqs1c!T>jwohYPz;bpsG#d$|L`9m7N0!h4;$b7tzPLi#E@1dH3bYmFhFa%SEo?+^8Qqx1GwqqE_xF}CZ^DLG z%A!1>Gb#0%=)$ZCk)Y7IjjkPFr(LuYxGY6Oz_6L`^FhhC%qi}MkasFUVrD2ja8-pT|F_q{fcdGt&*%wx0d%v@eHPaQqfha060gV+ z`(GC7VCZ0QPGfnCD5f}Q@H;vwG9<5m&w+eRTtZn*9gw^S^}Sm?E{I~_o*+Zn8X{ag zy@HEWA1EQ0ql5@8 zfy5L%R>fKR)}}C!@uT5ejtE2K1|#W@g$uj%7}Za&_b09xdCqFgEyiA7kBae?DCbpa z(J+z{dp55MoEfg-0#|hPKiV+wj;rU1!a0fO9Obs*VQU&OpyV);@?k1WyS(a}TfZGs z`>j|IV%7#E4#QotTbaUU$kLTFO6rkVfgf~C5@Cx$BD6sVmJa8?Vx-(x+7XYcmB4x= zVITfWk@2eh$V2=F5%=As`k5}$syyEVYt2!l{+0Ou&Yk!0y22iLq;IdddxL4;Aw6P* zu&Juf>7JqRZP3S?+A&C()xosQ(T7+7XSqtwp2w&>l*NZ;Xk%@%UoWps?v9rtnCBvJ zh7TDUMLGL718`YmCjM!-rNJ6@Ow^;0BI==!BF^oU;*11W`r)ZQqg#) zlrYA-A=wKw?)x(B=3+y_`ghvRcdV5A!WcXZBt@NF@aA91G{=I3Z}RV@4ev z3L+tB9F&wo5c!FkwEnPZP%biUdc8l>tVw#S>dYQb7d*j!)HN-zYVpB%7gmLOm? z#iPK=0f*Y3shr3{zIK=HH}UF7ycB&l8G*#dN?zGw0B%-I0z)`;H#DDxWPCtUFMQ9h zkc^SA4K4ehvCR=~z%SU3GEE&Q;iUkA<#nx(B^^|a*}y&-DQd3s0^~p552_;^_7};L@oW z+6WRD5aXAP_*2nt$*hM|DNsRQk<1_e)Z)5u8@*n@H+ z8YK$4q^N>|)?hVAYE)6c79vp1(6fe3>7oA9!d%XuKFDZV6SzE^_7h0SGL@W^Eelgh zoTHho&Q`g5JCb=3f*5_9_G@MP1a#>E(vsJ=Jiqrfk_#vF-XW$^_NCIP5d49DRC$EL zC{aRjwlwRNARp5p>Xkt#jGE8Ium%(;(>qcoOLn4j*dFDQFAbyMy7E_-+X#^8s_JXm?kapSJV&{Rzbq zYA5S^Yp3j^7MQiD6H8}d>Z5FuHpM{<)9FbR$jByKL<3g(yh6?0QD<{>E|C^Xl&W}_ zRCfM@p1E#)weG%PYTTRhpNxMOl(#;7{nZ+iFT!ICNUdo9G!}(8 zQY&ngFNa$k*y3-vVv!T<76z?^ge?qOcL7qEk~0n?6pfvtLL@>vl962Fb|j;W^~A;M zOV6eA0P7iH2PNJ|?C{Lci#=$>J1jHKVtKX`aBZ@lfMHBO8=S6G#L|R>oeUX1NNpu} zx#5GMzqEl$#c3%U1&{po!CECh8yZSY(=FD=8dC1pZsGLA(! zv3$0GYFW+%Vwp;d&JLJr?YI`j6(1H?s5bI1R4C`O^>{K+4jmO{xv)^n_w5tcgpZNi zGL#Yu_wLdPnT`uF11XDbGg=#_i~5n+M}JeLff7w*^Ny?)VuWlU#fBYlFq`xd?P`N; z=M40BH-AKj+Sn?t&KF|+OVy_^SqDq9_J5sBkpyiX=qJ-AW&O~st!A=GTwB^X1Sv&g zP=#zzRY@=|IHqBiruZ-&jH5&}Zd6%kPqDZsmTn{Lvi3HI8R7=7iM1L;e#s)EW#ZvewRe{4_TZtS~Jr9MvK>k1k9 z!`147uKG9Y}djTD2&O2vw=2@a3}48887#zRL8Cd#+2*irP?GH(zoU($>%Ev!W$dR=cKJ zHU-ksygi#YJn9L=zS{STHn`beVl%$ZT?)(HJaM&kZecWwoy;Z)?VOy%P-mm>Z%mYu z@CZIc-HSpja(A+ZasY;q7U$QAS|DAw-x^Pg5O_Z4PC|jGCS|qls5A%y^rC9gELDOzltGp`<@p_-68(h3ps?eHJJGR%>co!x!q#SgbrmJ_ zfTZHMMq0#lzJMPT0EZ;%V2i|Pi|0-=l0@Oo)j%3Jc3|il7kJL#Ks#Z`!laz`s1T^m zBhjZgm6XB__KWWPfh8*W93|!L3_F`S#w35p!K^b&Zj^&~R`Ps0vG;XYoh}t(eUV-1 zoRdvM=&{%S=i!+FTNN=w|?5Ncr=JEE+BHS>4V4) zHrWvKVH2HZnF64l)VNzy;BcLuJ89=QFe`@ZjV}=Ct7i*AEBU|`Ked+aaHp#GuJUB#1Tx%PRoY?cxY!$P7nYK4SB^QUepOn zR1hgzuBJQ7Nr?&^+2p9Q;j5;0cvD=Ssw5tm)A3ETSGG>?a~dW&5jw? zGz#16*+G#I9pR}Rc0~~~LI+B_D-N4dbOLi6C)XdJ%6!X+#2)a1$fY=;DXl#=pVOK< z9h;mtZ^lCahyZDFi5N~uO%X-KE4V3rdhRD4G{LTu2UYjw)|`D6Fr*wqMnH)OK_dFT z6etPb_A%g+eAD(>wnR|rMYH*O@1AN{>y-*q9xs(iMkP4y!wmjj1_c?7>cHBF}^a}{fH5lL$J&-~$u&?d)KC6ZjxclJ1dWpfEOFXavi3)X5b5HSr z!c)2pfq1nHeAT6@5&fDYL}Ow&WT*fQf1x8R z&>K3!;ya(9NfF0FM_5>H0#9r3YQ`@XVsV7UKev;1=^@IT2=*~-Wna*8G{c?tMj2u7 z*{d)ME8Nuf2okE@(iuzTjBR2JV29kS^LWfwfQ$K&JDe|IWU@O zAO`w`$i#l|KxTx@QAJ!kx2wHC1HL~_Vex(eub6u=++A=p)S%DNxy)Mky9bAB_d;7X z7F$0F{zD?(72A^}7fWG@hBo!>=lNK2+?~fjEMg+W%17{giA^c-?qV72_|+z?RH2AV z1&JFUj9{oM5=>C~G?@*c0}ByX8PoBQ@evQ#4>0oOTW!QUAxvO#)eEuoQ=N{xG3&|z za)DLvy;18h@Nl$T@6T<%6|y$W3u@;^VwFOs>(UnuXyipS0NC3{!KRq*Y&_-c`yotf zEn_O1ya;PD%BHLlaD+Su=1p0gbxL27lIIWPA^~dKv!j%XV{i-@CwTB0^^LYL#;lD5 z8ce>302>XQ3BisVN96EO83OcMVt%n9(CT>u-XDTj0bZM`Vr`q}7fYDHMC+1E*>Jc~ zuRMPsXON+Hf_$+vnc5)TNh4QnjT<+akwq~N5W0+Cgafb_J2Wswpl4D6wnD~D9vnrR zy1uyImZfcx!?=h|yZ)w~*hAqI{RQVV^;7R^K=9(sHazKcBOK(;ma=vgAS#;X(HQQy zv~0*-;WL(<4zd3e>x2~a0IZV zgw%%Fidy3%q~$ZwRCm2o-W!Hxgq}pD`d&bH*T(DaGso#}k);k-GkOGcBCXBd=fZFz zX=h0t)5bNgjsHN8nW%BvSnEI9@gPXoxZK@Bw|8bRE_l?MNwmlh7n-^uwBjt7kZ?JJ zbx#?fD1V3+XIKcpg)ytRw_vn2o&EWiJj|jp^gRGD);zM?4rx#~zeWTrn7=EkJMbJy5&_m7uXaKUQe?(y2 z+8FTq%Xt+o#BrekT803$6r*Wv7`8|uBzwSXQbHKQP6=6}6A)fDVBnk~f-g2vDj`a? zJE|uz;-v^e*sNbefY(B1{+e#&L^o-mnlun^Uj!LM@VL}}w-|wNJPbUfAyl&nu{iJs zDfk+KRO&|qEVK`gd&(Mx1lKX?HF$=i?E{n2-BLuGyyXPTQUX)$*>1oDXv$&>>>8nx zSYX=5csQ%^DJZAWDwXH2aM0?R^Rig$Ig3qej$0UySk=cbjPGe6jGJMZWZnsG3J3JG zYfeAf8B9PxGB~RtwJkVs8cXn6-oYEpqTb&~n6a#g0CY7KI+ql~|J0A$SkdlJAeGt( zFbT14;0W++CLTb#ospiJLAq@LGcTpZI;o#!KU0Bfo#sLqu zg@xNqHe@n$hEa?d7uK2Z0_z#taHtmVRFE$08_rkw&a;4VLlmYj`wr-P!fl_)_e$=u zx}frG(7q9YVzegUZZw2qGivM1g#GgqD_7b_ee%QC9iEHwe!lOO{Dv^i@sxt^;@p9( z-uY}?y0Wrn6350_qO*}9iyWO&99C~xq{U(N>=itguc0Baq8x&g*#4UAHS|5VYZGvS zbK3igHzByO2!It+C0KgNkapkqj~f5kG`C^wk@T-o>TF8Nj!)LXJ&*m6qC@=zZcJy| z)$9-4`w8y*ihyDp_oP9AT_%pup9Yr2J2AA@&$2g|AWtaDQ;t9{qC`WpN0q}BFXL!(=)3h)S*1nl z19B*c)&-{eA)WD-cRa0+PW2Ei&qwgz+RKyUU(U^LbQ8c~d_vYCaIq_0L=I?{O= zOmU5`nxaZ;#TWpoxd1$j$kr}tsF}Alf|lN{Wv$|EFu>ssLv*Lp5U9ukmsL#cZIRr1 zEzxq}KN{r`*o4q{qxcTb&`|Qj;|6#oW69EDIeOx9(eaN z-~P=n-1GLgf8_qR>@Cz}iZ;mf?2o_lt6%)PgP(roKXc<%XllMIcJBBWVOf25XZ)Ky z1WOWj>Y=!_fTWBwVlt@wYX@vpyokNbcn-23DXw#ifV95-Yl@1bo371b9+hv*{OA3O z0`UXECpYbL>tE5#vi%gEanrt;kG$*pcfan}YIFDr=oGCxNHk%7%*{P?*9YJ6!CU_+ zn%NtMsws)CrOwwFRhr+-fuPsjFgGXu`pBI)mD z;G}E%uc?3bqX!5EsLBO;<;j>{X~Dni=I`rZGxWN*>@|xH=IeJpE7}SGxW+e|{Ehum zqX*c*I%v%1r;*p$`|9-oOw26Jaesn6+UWuY@ip@@J8f=ysHVBdUGhe_WVGROUwL_B zd3lpvwxZrE!-Z|_=uq;iQ1a@s`fJKd+qB|3d~K*{A3M>zmKfk39^E!EPuR&U-`y}8A1Sg~5+JA*7)kt6ic>gk)uQRkF-4+t9kVzrH5 zs@~jcHwAFNY`2E(w+}yghuxky(t7VUEB2##r``05I=y#|7QEXE#=>~JJt`o1&+zT9 z*ez&3XcxZ2JM6~5eXm`fQ1p#?@~c)&v*B8ud7Qb-@08Uz=!s~=YbJ>SY0}xp=0$azh<}HA_ zvjFNZP-rBm($P0$Xz&djSpZbjR!XmPy0fGdtS2SaI>Uqhpcf7c~KFrmmF^mX4v%_sXlD6j3ubz zxXmFlJD$?JPHSn`uEG!cBJ_#;|8#@}w0k5ete@WPrra<}0ruC4$S0d5v@FA84)wvfqS;?T_cJ#Ga?l~^Ur?SoA0S>&UZ=8d5~+vHia`W^hE z;uF|y0`u=whg!WPA&ZoXo7kbXPcOl_-R*qU0n|={Pjqz;qGiQED^%@#{f+^P2!uPy z4Yf~SvStjo_ui)Fq`>J)KfS)rTT}RZjcDHOiDQ{&g&Uzwzk=7qLdc-{c?Jv5{`5*j z5$ihp59YCcxt~(x>F(DY202SuSeS&UXW89j>wY;YK1*>~Waf5f2OMIT*`VE#73|1j zN52BDZcz-d0gyl&VGsaWOB>Ge(>jBmP)J+OkaQ1w54%yhwG6iOWcu`rtBsws6Sa1ElD?U75+Ts(e%oPz{=h*D$~P%bv<*AZ z07xchibWC9m$0c2NI75V^%G|6=Pa@E25{tYUt8)~-FZ|N9RoQM8$$jc_TE3*uIsAr z-Fu%O_uSt{(zPs0vb4{!>`1W%&KtqbODK5XLV{~(%o}+b86Eu5|6a#c$cP+c(pHgf zuwq0oL=*vP;(|gx#pU`7niQQV5~L2$c=2-*}Qcz?ZavCBDC(Eo4uYkw#ny5 z7ZDQ4(SKiD)8|kLYfCcE=ToAA_@roizAaxMv7crQK3pXYz*R+dryFTW;2u_O32o zAw>ilegQ!D7qWAS^~XE6gMo6+-!Zr*zlIU- z%&%#@SsVRGpL^_0#!C~^ct7jiTJ7c-M&7+vugt{p&QN!z(d+u-&37=+8Nv6u{5nRw zGrz9!W^ME%eZI`zWV|#n1CHw5TJ7c-M&6y(D}#LVN7Q z$T-w%I5W~7OUzDJmyG99CJ)sw@rM^7c%aL$HjPF{xIEI!oW_l;3rmvZ*ZAhXS{iJ@ zot?mKQ!r>C`Cz&QjRMKRB3cgA4~n9F%$1$0G>ykdSUVYoXNf?&1_w-B-i?>4ZO&aH z5i|MKBsa--l{?4AKUCZ7q{d+7%ehmX3y@Xkgn3b}&OtDB&bm=+cpdNC?Jm>#)q|N9 zj3HwdN)3IUz5~n&ZL>8u-e1b3XpjkN2S6z0ftt@MC3x-#X|IQ7QA@%XYJegQsLSSf zb2D3Od>*qP*R%j@6CDg#C4=D{-6^ejV*Qc)PHc>U2d@eXK*3g_dWDrBzGp?Ebwan%yVoyz>Kx#1&q7)MHhc#NFD59Ak+MZX?KwE-;4^c z1^xHgQoMXHFf7@e4-OFFbF_Es@MS_#XzX45UgZqI{Kia&xe(&kJBHUlk?G+Y)lxeU z4t?y=mpwWm=6IP?>DmK>JsJ})`;NPo7mR7q$xcNEBj-;Hs>2!97=+Mr<#Xr<`N$_v zREU`iKXY}ig;NH5n>@qwj`ny*!d;j?MkL4?JD00J%E4v znw|Q}V_&Qk;9{6F2LKF5+HE_AxgavgXZ9zFf%Y2V?)4x&+krBmdE{;OVCXoU-J(Xd z!E<48-nxaFp;EE>_B+@VM$?Cl7KMe@q{cI`U2ATb3o7|Azg{n3GSDGtCj^#lu7Aq+ z9N-Ti<3eAyB4N zGpL=aX>=aCz;;*g1+f0IZSD^S%CV0sUUE8=Tx|@PkvV*yQ5L>SvXQ3RDvo9=;kG~B z?t^D$?e-Y{Ozmwunk1Y2|1*-Fa_)G0DZ#|_a;1l4Bv~#ZA9S;VW!0N z80*gB4V+Lg&>2SHSr#P|n!xmxFw`mybGF8CU}Y?novOpldZ5E*gsQSyMkr~+2!y|e z4Z&X%=1+cYbNw~m_7~p~U!2^Z_Rf$r2+U>Z^tsk4xVUkrDY$1uT`!eg{>%8;N8>JwISazd=$16mblJQbR)yIK*ZMorv7#{2HCJI>;ddn`y-u4TMZ< zYNQEW#AdIh(@<5w#hpgE|77Bo*n0!t zwyi*A#bK;3sV>XSlxFuZ8$NQtNA;~b+LlmyU9^YvmC{IEscG>#*DVtNw?y|CO7d2xcboPm$xX>?^1ge#_LVocm-l5Yx+`PU}Sx; z-SQ*woh+gEno0mYvh+cyZqzBGmH%rtmrFHisA^L{-?g&GG+&qpqfYmEsrjN#7mV0e zoT&4MlaHr$N=Kct%TAttZ@m+=T^s8c{xYp+bL<}&CO&NNKGjL9e`?_(vdJl!K~+7M zV>TgMlAhaEiJ6itGjpn!LJr3pHkmOg8MKO|Y>UksUyyIK4=`^5*_a4Sdom;fJNk^~ zKbjBjgq4Q;Ved>UhcE0DrBPO%!l+sEa3Zf4yA-b9J@cD(I-?qlhqJVOE%u5Wb@{eY z?9z)fgcm+~fgwO`!YIbWr(T>PJn*rvVhGFCI)Hi6IRrN|1%u<~;$ef2$}3ANlf?jR zkf?vod8*HD%@!&x^C`5<0fGC!s0#gG(qA?wdl~z(ZCQP=fknO_(9?+K@l%F>5=TKh z<%9_Rv#JkzRT&;gcP~;F@;MAZ7&k`9Nk8;~to7<77kSWB7%x*Pl0k=;n2PS-=AGbF zxTKEFn~Z}7EjY&v?&PA_7-~4L)0i_KYYmoCza|(mq$3AfBp2(}ttgLM7SyTp3_`9v z;<}T^BmSuNL`tWeTuJc+M)MDe@x&C5Z0}bWWeg!+T@>maha-K#Zrb~})$Zw*6r79* zhRdmK{SzGkZ=NSwGR=xvpP(b_$}V$*hD%W(>d3L0DK#scryr`w6wG+uW{iJvHRDd4 zai=lkR5P}YX!Ta9=yOY28)nR*?-vMl;!4&(nO)=dAv>Yx4Jea=)0^vyafn`#0(MRe zbeGu)>Vkmg#+(^RN7Ryqd-0|rKAnte>x~WKC#DEI62v)c8P8Nf?g)$_cE6HlMjoL_ z%WgOH7%%~#%}7YOlZkys%yM&!xh>(gnm#7zeJ z`cztcA=qUtnwe6B3cq~RA zb{wlPY0ug8Y_FBuFD#&dbXL=j`#?j|Dhf;Z`lNl$IB8$_d5yp?S2gD`drIh1gseDf zq7qYa?*klmeJv>4pX9bH&E1Q&1_*f|eYOgZ+bV!pPw7eTL0Q`tj^5mQg8hjvy+{JdK`SU$U&hTjSUu^z*U5yv&941nZzxIVU#F`1k=#WBk8+spAh` znv9$bBd(@F`=uY=>YhNrs#Yv{tIO8=O8j1BX|>V22d%Ut^5){o)kZqF<{Xz5Fciq zFF@6!2$SLq-onMbZ0BU{<^O&uFUwP}*0VT*Gt5Pw$5UV1C)1Ed0@o;ymDQ*@Z_^3_ z$1{h(Nz%0Nw1fcDUD{~!5byOS4}rLdm)Dv6#l1XX^5?_kZOgNyC$b5Xw@$TgYe`IY zC?LvA&Ez$w+5<(HAEQ-4`Olod@#9-fwE(Ju3&?-58bh& z`5aZ91Z!_P1id$FkgTLugD@R_HEW=jtJUxj^s)wHI8_rEfA;6t8^ykO1k}VF;fQCD zf7A&OdE6{3NBj0pKbkLcD7h-Td#P*PMqtka&hmw)wdr>q4i%) zNp~g^qy2rKW$rhcp?H!0dvP`-pw30V<9axNDJhO{BI$?VD;x6O>}2`uh0o9hS0`Ib zJUL-c5Cest_JglfC>zj{vfRLL6XRY@Y=PUOF?fr!m{j`j(|D5EyR$}$w#0?Tidt$! z7owGQItk_CjiWwNcrQ)RNF5V2yr@gDahQ4~&`FQ$DcdMlo|YcH&%j|79R}8oU=Yb^ zMTsi`7!L6HPxEFWipNg5@6Yt(ykHx}-~X0Y>9!EC(h>-8`!Dj5!Lg^ayc#GXQYsm) zepuYH$<)}wk8*02Y_HHEA7M?hSNvhX`1>bH_7B%3`xpMsC%kM^3yZ#I!}-dC+wYXP z(9ECzTy0UyoakN}_WCOtqIApQC;>_GC+COG$QH0fa{f#0{bY72iKtsqs@czNx+rnF z|0_;EievCMzpC%Pv$RLUWpKx%tYDiJYMq4?M-U?bJtKyvVMHx zI9vVoooDBLL%O%KK|?e7Uh+I8CeYvRY?+?b1o~s)IJTDP678&w52w4NIGL{0h5A!z zZsI&{#>${mNHtW`ffrG-M@X;a+zUwdG>5TTqCNTm86fEiFSRkz z9tdk8@}v~&F<`k^-=hCYthY+VNzRbRYBv-2qy=y(;}jzv7cy*GlI#JCcLi-mOC#H0 zhk_F_9_8H2#`wNk*`B^=SHe9V)aG0Y_rXoDLIQ*FM#B9lczSc(-Mg+}Z!8*M|7s-r z3rwOE?Z-#fuZ#5=8^zXdT&$n;CT^!FDF9n3(%+Y|V5pw7fWB}|iJk*D2=s~>LfrxG z&XwYPuN2oWQkqu-cAakME8=6gzIRNLUr>EGn)M`klk~M!qbRTXwspnxjmq+~>&fz% zc%qDWk+S^pbO^+pLSdL;^BQQ5v57BPod1OJaxX7=x&POG-xPl{BZ>Fgcr5jpd|$1c zZ8;XK+=c?&m~>BtAlws)N)kU#+DWoK%Uz1WF4~))=!j&0$`C3Y5$#Wv$kcb?Ub;>2 ztCH;#%>-X+?Tr!LQGqCK2}s0O_I4{05B&FseOGeNSC=v<;$IUPG(_5;v{T7vo# z>uY0o!TzGh9>jX%YHDML?TurfB-IO9N5uM*;8qY((3IB15EJZ4%uor0dizhKc(a#X zZ0`X&9`K*bNnk3{(5jk>qEK4A(qs(=%dAO=QaeH+5_64*tW9~o^3d}O`kRc?6e=bAO>qb3UV-|x(di86vmU6zri8Mz{@OEVnD zl{h0fO^|2)O)G83IF)=NTdd8fgZx4g0teoOwJGbc#tlw!X+us?OmM|41_K0yUS@} zH8Z7 zf<2D1fa=ec0z{pPY4cwAUz8nS?;Em%PFyoD1lypb2g;)Kpo2%#G3mj_ENvE(k)Qxs zbJ^hp2_YyV=}cXAI78do17;#)Gaj$W4ky(wa|*J-Debpax=Z(kxIaF{tY&mcgYX&45t5N9Snh8b2ojA#w=r_GGR_dXXN=#8?Bc2gLA z>4xAv5m=JqKFJaKnMYXy#!Fym-BP6TJ-tK&8y%|)%w%J-1P-KVuV}LQk4ZO-gi3;h z36-&N#;yaZ92-~2oDyw>i%cBL-AUF^tKgypd9I|Ye{ttfiV_nCw;@8M*_qpF*21!f zXvtgB{4p_3oTW)D$iqb03B@ttx`fAehdu~R~Ty;1xrPTTLDBJcu1<=-t1Ib$}OlBHk4a*J_fnP-#r;DCvjhw!V5QN3%^e4 zWSGA>(+N?YMts$7_;V)#I)u%DNU=4;Gm=_JhkD-ki^gvK;JXuX(N47}7X5v<5Is~` zh@x0jJa|&u>61wL`cj%x1M)VcB`JfnjCE-V2BeafShh*h(wBF^@3mtb?`ms35385> zy>C>0?(De`jWrMdi)!mytgm;m6YB+WK z8*P;d&*=$FsMlfkmi&Y?C#7f;*F?d*(Tk9JCIZdXL?G}~SobDP1)aadb^~V#Ny{%Q z5aKo{m@+lpX3_v=M4gKVX4-$M21zDk5CoTL-XLkefuuUVXh=3&Wv;ZcPdj8`Juuem z03Mc9p{fyJ8Vjh+@U)%gB5*AYeEnJ{)q4aopn7Co3iS+*25=W!Q*cz5msmP^I$H?Z z5tO2_WpEoc5;sGu#Ru4JY7zBhe7>ODAXuVrcxiUEwGz!wlR;4&``2O}ur58WFHyEF zdXS06Ra9e1^B+5|7xxv<>$CK$AKjZ{oAt$N$843-fz)l4mn(h$^wl_ImD0DeXeAD| zk@%(ynK69RPyVa3ESflC#FNHf^N_+L!Zco`mBV&%uyTAIM?IM}C#s!-7|@cZ%eqld z91_I~4eu!Fgkuaw&AO4~##)4^r(oRBt&t})SOsZdP?PD#P{HI0ah$S`X3XhcR$0$@6aQk~(BSUsduhR5nNB%vwmrhi*xF{Bnw?U_w7#GD{q2s90qT9_$(~CQ3_2|Bo5I(NM zNKhN6rKP|fs!(2XZe_E}t8F{K_*`D)EGXXn0THliXYI%XH%rAu{_EQz_bu2Z2&17S z9gs+$$Bcp#{%GDmx}4svSc^pqb4ur!&%$!=*y)9gWW>^5!zrV}7K_T*U}x;cE>6&= zIY9wi3(Zd1yIWAweA8)JI5$DoBI}3$oO9*BtRtS=;ubwL5HrhUxXRPZ`lBK2gG7SG zDMp(Kn~Z_A>{&Dt#b?BUU5Wu9z8=PpZBf$|Z|63q6aZCfX16hotfTG?8En#+A#pM^ zg|Dd7HF#Mp&1bUKCfHx;8-7)A8EI2YXaC2XC(?J}(X{iAF0V|Jo$uz>Q+6ku_ngj2 z-gpsX%RXe%_%}ysoFSL7WsJ76+yWqpP0%(2oah)|&|EyNPu~WbPN}-kC~La_!auS31(F>|MT4V7uWed#J?KdPj?_ zoSA9pejSuzc@16mCwaqQW)QKEULlg3%S1}-N{6>DIG5?{L)k2j(+utW|%h8s2r`?i*WfZ!tY#Ei}B z4{%<)k&XDr#nXchjROp0FKY&oZvV#xUcIT_#e8K zfVMC)Esf#5^{Qop**2OprC#kD$tMHz%cxp$RJwMF?@oJwTwG7}02-y3+Qx(TSP&W7 zayn&^+|1VDhZbpJ-9_5ui^QTd7RmfGY;ig!uwUu|HSBgkT05s&CD3x=v`v>OZoEps zQK1#U%f1oZ9fgGstF)1Yj~*Y%gohEm5bqqb9yW0oy$Acx03#l7jm!oQFihd;nGEO~ z7~MLku2oVAEj6rimyo#?M=oAFYw8QlOUD@_w{N`sa4G7D0^p)%;--0&nD?4AIjS{a z%=;M3V9`6>7EUS!Fhz9X$w)9HJwrz>!}iDyUf1@h0YvL#lCxjJCWbz059Dk?W{BhU zO&s>xju|c<^0Ktdpqk>a%K}be#3jKT_4jef57;PDsw?V@w4RCDAm1*Qdo@zPGsby? zEjT_HnIKyV9UIX2O0E-MR1NbCSM9C&(t)p3Iti8joVL6nkwM%~8((i;ppr4j&~tCJ z|9RCn3N2ljTyV4~Xu%9mbq_T{{H*B`TDR~pCC!AUY2-u`uEgDNA$0AA7+QMNTEd8| ztT42hqQM9Pu+aHgll$h2FPqpGoZ0ARUQ_7i^AY=jD6+V6%#nQy=t9#=bLi7`kumD2 zfH#X~-YY_rd;Oq+TKdEq2o3%CMzI^CTqz}Oi6u|NL@{QjkvyZ~SF z0z7ut8@eWkRMOt0@x*S z@&<;#|89U^F+ucYQ4lSjvEMt&-!GYk5$eq6@*Bh~ECjwJ)2}N8j58Gv>$efmh+^|3 zFymKm!gN8|>SxxJP@ob?c>}5@CeL_T_Rs%<&Vih)QC;8v5vQOAk{{Lg;$GzmEWWLH zypb*kAN5!GKXH8`=`_^&WYNFZq-&aVu*Xi>CL(1i(YXn{CGq@Fif zfc7Q^U7$jdB*)!<`!Pg!m5OaD9@A5eW4bL>5s^+b*H*v*KL2@JatS>VyscZ!(5+Ru z*aDOp1H8BgT}aZ_8Hwi3w>g7BC!eZd(2g)@H(Vcy7vx_ew=)xKSqrWCW7i|ndAW6HlYea4fyTf`x z7gIz`@K7|}tp`){iu2a#;NCYLbfI=1SR#qj1IJC*}R(9#!)>M_lfS87AH?Ys+ zZlF^r4G5wY2s^_y9~w)k$rg61-%AR*XuJ186?7p@PYk*!ufptTFqaf`p}0+k(}vWc z1X3Uh$gH!>6klBK8Fe8Fy4WO`vG=}nUN*@xM1Yh6U(ehWbYX*_3U+ogsG|UWp$nF(uF#3lo z9bBo6Z1P%e=^Jws;Y7WdAdSCF8=0OmSNL%dwc=?jKKUZT*+t2WrB<8GUMU3ZN$Dw7a_^4Iutn1Kn-^Dq!7;_sOT3T6(TMSN{ zGk8qykb4XlFMxe~mnTbG%(R)yN;Y#rh_2e^g3>Mr6*)-wQoV0ZDD84)@#&>Gq0lwX zFq4GhdW_EmmXN%yKMR@MW2@`04fDW(V8b z1mW7-c99`V30a$xM>=0ItmL9USsWL9~Mhc3AU01lvb&YYY@u?Y0~KnqN7A{|Bo7X+H~9Ka_6LxYfO9-G1D5< zy&YLKE3R=!51NscQDo(;DsKC7X2q$p-mEOndE;3%6D>{Y77@fDTulUIAnv-WsVI_# z1WbW9=Vp`Am0)L`PaNmC*;SP*fn&7*qZnG}z2mW4Eky4A-uC<*iueHT@9rR2F!U_n!4E#bP5&Gk0gr9M+J zT>)ml{b3!sso$W@L<||@YP7jX5FVzytp}xJXrXwt{+`Z8EkL6&$^`c*0ATawGu*@N zl^ZQk!|-2}+oZbCV&f8O&=5^1RrjJBgff~*O#L=$X%SufgE%O1uNaCb4&uZ%E)Lq9 zg?}{9gj=FmQ^5PkzG)Oxr_cLKU$ni!7Y+SeU2=TX6O~1|l0NEB zch=-e4$|gB&%hSsL5r(tK0j(wMj%CCfZA%-c)H$s@swvtYYZUdVhf#conpNWmg9+W zq0?_rDXuRb_$jccjHx*K6T+$OrTOjbdq2YO>x)MkwH~=&wKf&czpM7HFhx?2UtydS zcT4EYlO3D*Tuu0&aTGXFLwU>81CStgYL$9GC@~>X+b{2YNy3|aR4ZZ9h7#VHnyKI= z3GXEdFWlqegzqH@PezLn;Vtz{Mx4i(}fwY zF>(x2F>R-^p(1X#nW(qfMLm4miByCjz_;Z@xm=8#HxF|S`&^DIyPQ_|9 zIS;KE`4&wrBdK;&u0wd}AWBNAlZytdsR@PIuwTh_Rz8*Y6$xQtjYaejqJqe$SEjHH zBIvScN~qJq_{p@NdPG$p#11jbc~g9z%Cz?cPrF?&%2 z#-}ebH}Oj@XRBN#axpGv=WCWi<@F3);F-FUjWmoV(ev;nm$SM2a*TvhF>c^CS6T^! z(*TgJxek84xSV}0Jp4RBHS{@)T}Fwqyf>$@9ne0Je zMq^#m;$@eBPTDaq`JBN8zvw<^77j}qU&Xk~!PAJ8Zvpq;hatij&KS9haiT)g=gh4h zW@@n(!yZyZG7T{7lbJ=-TKPnGGwWLJX2#W;0veBT4Bh(}+r_w>Nr+HiGL4P#o|nmZ z3f`r`fxuU1cAFfcUtwuasQ!|ZTk{^uPc*o@%XIdNhTQ7YP%7QP{R5p4EK7?oSP8C1PNdL%>67zLbChn!^@;;eY};{7M!#`?m)aWb1Qx zUX$Se;;9;UXKwYb<70-E8(84(Y-VtGMDRm9)Z0zuTGVWB%Fg1jE*~k8+P>vC(l@d$ zkmrbL1D+67aG5a$^t};tL>9PeHT@gX-TE;F6QH$DOaU4exn7)N87nWa%VY2^Fo%-C zn>e^SgZJ>b7nqg-FR+QPHk`o3zO!Brq|6Hpwl$4j4DlidZHK;mk4Ve1H``fEhp^3U zWzL>>9UPC(W{B0n8eh63X&kZDzNNycx2fb1WgZ;9%dp<#4|LYmGd;_2ayAQTcjy9w zi1WZcGVs}r23_SfG6$=PGq(5w91TjxFOM%c72*r9FoUY{b(!&<@9_oY?3|yRQj9?} zNzs(wQX(aIV}k^KPrzhUwlUZcCJH@bE2Dj>N!K#lfKL(3yd?iCWwvQv*5)28JR6v+ zkFK7ep>5^G4szhy&rsxiRJ!SOw6Zop8%l6L5_Q5eAzbVLM(0#RWRnjoz9Ib#bqJ0E zn9gzU@GV>>ijh){Q`_`vUFGtyZ&Q`$1mcdz9$@PC*n>R!B7MEY9vBcEemFl(!Wv-d z*leCezFuY0nn%p}1o&wB=3l^6gDU`dG;tw7*v3M*$JB)uf@OgALJXvK^Y{dVs_>|U zDh^MVwMaG3u%-_cnlVNTKA4jb9Gv+FIRbecgDJ_39SS*KJO+ia1(4_j2q3{N36uex zXV_`xDJAF8Qm4kV4SlWj<^~>Ci7txJzS4MYpT&a@plFwUKyd_o$CbRvSIUDXIM(Pr zukLdWhbP=#|L6U6Lk8m*S^NtHD9{vx=)Y4s)QqWr1L^@;UZ13U*9iq}Rc)C|zYfln zi}CCD-IsS3Nov{R8nITqh;Mb>izO~nS*HPQ7#E5_&|u?)17hR!DK;*vv2m2u**It* z>w5WY9Q)*A*tp{yAwh7`q@9s#&ygE%lCQ@}6LVhR1U*(`<8;|7t=K6g(p@ofV0_%; zQqw){dw^DygNV6{XX6MyueZc*Melxw5>r;*pRK^ksjApI+yePdROevc7(24s!rxws zr$6+@7`ug>FY*tgy)FT>1j8(tM}Av?-{{{cqc>j<9-Ro!DcxS-p{T$^ho^;)GJ9k7 z3}(^cf8nxpc^8;f$?B~$JiE0^=P-=M)8ouuizhLGrK3QFE5^oFA*9-~V)p{3GcJ>v z`KuQu>p&C^;=rYO?F<#WS9MA+&I;V&K8_%kLH_Vvdg|DyR@k< zTC&SlCuX~BE4EO^9wuH@*S)rWSvqkn=Vg&%kbF~ES&*EIFtHdJf7r4QEv$-K| z##k4k(wqlWvaoj;68Fvr)1eXLIB<)GOv=N*-aN;7Mtgv=;MX1g3itwzX^Sw-B& zXO|Y9P_ABNc0-O##$0moIv~L;N0#-oWa3jBvSiA)+`hVJy2yk_<;5-%#(SZ zLBu?ne3yJMAy4M{%t9f&L(7wCF~y$Zb4n>r{h!8!4V!*V|Dw2XeLbn9yHO-3Yoo=t zFDSM^osI zL@|)k4DY;L{P3!_M63TBa-l>rAZ}&LV2S;(eo#Vlii+ewcC~3=_Z8p;n=e#aRSJm#V?iIdYY=*B5@@q;2sFWM_Zy|f{!;I$*c|~BoGyB8z zjJb99>=^JPmtk9W0l>#C+YQ^**SQNm7>(}e1gdtbV8;^mU^$u_w96Iox@VC;jai#xr$ovcg3qeN~!vZK%9UJiRa-%|SLP zY{_(bqF`0v(nFjAXbH4NBrsK0B7Ifh5;u(KtMaSP``1(OQ(f&dl_M0fj}|TFNuYaJ z#4aYm1r0+ITuX0Yn0yxEhn_;tCQ%(EnNHdy`Q?~mNDZruV?jX~u`Hj8Y9mXG3$}P- z+=t7+D7idY5KR**C^8I~Ku4TH1yU3AXQEWA9FrH76BpPq!fFTmX=r2(7KBlW#MRai zn)56)M}w-=E4a8+`UPW2ZP5H-h|Y^>Wn+XqV;55vlH!gmEDWRK(aMFbG!a_ZC0{Bn z?1F#Q!s6N#7dEWC7Iq=7y)Uc>vx%NG7S_p_NE3>TuvlO1qH1rI`5IUlwOg&MG08w> z1mE#1tFLSYVhM7b*%5kqd!szMQ%0Qj2$SPoKMtIosNKT!Eb)gY7+%uq6BJWVtb3Nk zx^t`os4vQE>~{!D6OyS2ucNWyn+~IvRo6C!YQcGgJcQn34-bv-0_Q$lwuiWZK7_cnnNk0z^#XoFSsCIc1enF)GQTIE zdGIJGK?S)L0H}-F|!JO~jk=iMQZcy(|=4PH+X>`VM?R`}yWK?ig$h`SvAC{0v49;t}%} z4rMFKW?cLnC08LA&k((bH;yv`F{@K@-1HH>QgCKcgWF zfEq5=&{WZ}gEr2Ansze*m1h@%wF|Tt`P8HzDh|0$(UFrTeR`O0q9G zp5B~XMd2VE5Q18gsJRZ{&9B;h;xHQ7mG`FH-WPb&^!;aD&>1YG0 z1byJX0Fx)>l|fr)>DMm}O6*(AsbbYEuKB5dwYFMak-JqpR$ACoDO*{P&pWruj455S zO)F$T@UB8um6XvLg%+#HlM}L`1CDq}(4_2q-8`)TaDha^bgV8QudO_-0RW!VRig8w z2*9Mxl0G#lJKrdrrcj-gsrgdPx}%$PI2gq_irt4uwxZbC8BoB{^CC{5)UA$>jGJxB zynLQXWy&+D_{>DvP^*r=$6ZG@698sO28EX9`T@#1T{Tphj!9I6=wK(n)i)VOX@PHZ zMK@T|d&O5w=h^k+k)zi0A8QA>{;DUNx+6yan1(bvwie+UitD15Q4E#aju%V2V? zxhrMXZk5eP*GRjr8S#32a$`wSbVIJ&QS^ClI%Ks_#fx7Q3x{$v6=G^)J?jkXMA=_d zMsfwo1l(s!JMP;a1`Qn#5W2tt?u9TUwltd;iNx$&Lt>Z$lhZ3T%IHLUsDFS{*HkAw ztb>+vrc+W&vlvhu&6ng$?jBCm(1 zH`(}Bn#AW=5^i)&tfA6bkfaVJ-itAMc|(*52>e@hbp&JPLYtVgaAYNn`qx&%CGiWb zgxx`ddx+>)>OKJm7Nb}ZEbz^LC#zJ`NjH58(%?ZUqUJsXI<+UP12>Y5W0AAoY|D!K z2IYiB9br+&IAUK1-7o_Ru_DmXJl-Q>5(oR5yb`une8nv_UbD$COd6@&IKtj2CEMy4 z6m>Z6ZFr?J-3y};QVq*Xr;6k7biXPdD2Tp`j7A%h#KTXXBC;3>cgBc^s(~9dTqn zi&O6t6`C&|(r0=3<+GOUc~5cNN`K8#GgQ`uwTY!q)Jx+;)FB2_8^CaL|KIzB#Q%7W z{)dePOr-*mj6|v>`(mO*B0!Ll#V)Dgkr=_>`M8Nn1}9!%#;a#OdSdlmKYBzGR9bM# ziqn)QE`Mp2zrv}t&=2MPqc(~~Zo-R@=03blh@a=}0ffa;)gToY?}4G3;Zt(@mb_Qx zN8}7@frp@+Zi5xIa;m?;x4y}=a4yUOaaRv_O7S?{Bv%=Jqb@rIA1aDl{9f{UTf?~S z8lVa60@^VUsm-lcs9_>x5b5INWqB~+&A@cbli^rBstC92CZFy65FFZhg#U~~nnJ#) zi9|VsfHXHcB?-tbp>PN^b+wWh6K^x=|D-RUoLvTr%mTsT*-WcTUDFt%#^6oXNCxtt z%1!qr3=UaVbUCD~lBnB}sGCT>?FPX%kzl(e2)13<7neAob!8|3h`(CX&ucgg*F;9t z15spT`8YXpJP{e>G<**1s>-CNna<@nQtbVHLv+ zT0o?_rpOy(=+G84Gj@;~2}18Nb~@1mz&T+ToS|Z>lC-Afl|gCY`CnXpwl}-6tfZGw z18F_t!|L3#ho*E14_zJ8d^u!&@wbbR^(9^jW-UDKQHY_&W1bhLQRA6LjdRT!4Dg96 zb4>A=GKm!5Qrz3f1rsl6I#(w%&|haUT(0%|g&?~|hfBHEc63dyW#uQywf`ecOPMxD z$Fm2@u$tr<3koiv9W+d571>Ir`tN7A6i>jcg(ztbAp0rt(Ua4pK@?BxqPPjf>}j#} z93RT@MCPS!IgShbFTXkaR=#rAz$;ayylUV^f8hq6fwQZDgpm#^V_f_{k~^WlP|bPo zxfR*Hv_-5l_M!1x`lX5GD?Z2B|C~0mxwgDmN0Knl zBS53wTGs(=4botm1wmk=e?qjiG#vQFW3@!Ck9s0kl&3-eQLMreKL-mXjf1&Du@>eA zB@G1&a!%|O?S*Wv&t&S@C{q#L1^{{`vs~b60Gey(7vagjmeQ>h(-;w$c60$lESuy4 z<`ti6trRC4E@1K{G3CQ^44cJ=sN3ZLEU8?;Y;Mf|an0YlyNN7nu$S7u%>A(zZ=tet zRm8O4T>OlDzkFD72NO3+;-}KXAN9dyyMZwt^@cMJUqs|-x0~18z&abPI%6I2_HQ_W zO@!#iPGIK@YNfq7znp;13(TohRID?+x)a#r#>{r>d0$&B1lo#qUM5VpGF$6VXH9W) zFkH8_2el{__KY}ztsy#w+^>&?+^-Sz+FXwZC$Lu9axbuFKcHPb8xUW3Jni0kCTrnd5|&anWKVPc;dmG&l-dASWD(70HsdR5nW&o|1NN|wx(fQ*&McnHawZH zH>Z_0*xLB_LZYGAy!kXP1FtuKz&ZWIMtQmZTsjIE@x;Tx*FuK?-@?HVU?w~pyBwp0 zoCZH!-;YZRWjJi6Nu9`&pybEp3!=u$s2I&JG%Uzk(?lkWcygJE&?wns5J6h)a4o#L)^upN3nn*RYht*KVU*ehCw!-3l{PD673)yy4GbY7ZHQ!~M4OUC__&}j zCO{g&s4z)*6zyaUmkz)DLK?m2Kn+=Em5Y}Hl1(m;4zVvH;x$(tW^Z&XNNUA72)!|< zN%1sagD=MuG}e(K`79*PH~>2joWzx*M;Z92dcqF1rcW59^Qq$y9HqOS9fK+c-wxX% zYD{IL4m&D?(3+tb-cp?g`}VPxE}CXTiMNsk{XA@stNQ$6`*F7p-1XWpv$ik6mJLw*86El+I4dzm+V*;{`U^T|U1scU3 zH%g5Bx+R2EO~(d=1~xjzU7b)B7E=6pYt&DuN?^;|=)Xt}ZF%e`x(Ka{PufUze5$fL zm-rMCR|}uEIL-*4rd_TPK6Nh-pW=lq0dKxqToUJ4`U!zh+94G}86P#lPiTt}D!73G z$4f`3>B_4?2(_+Kbc&5b>xo#7Q!SGcGnF8*i`*9{Yh~mTqQp1O&@vCJs-S$VC8;!# zw*FN%T+sm6u?m4yv^V?K3GPI%T0!+t+c&Nn@QRIn^BtAi)rJdAaK9rOzCAv3jCTwv z`644prcW@`V7S?L7#n3Hza679$hI&0)&bJGhKWm@DO&jY49tJj_$XXa1jFb#UrM6H z^w-df>HdPfp@xH~UIPFjbfeG%8adj!s#Qi?c`rrI);~3x$6U{g1RZ)lmX=bnP8OrB zL4wqW?RB+j7W7;+4Ye&=vg39(X{_i7HD~mZ%jvt0-tNrg3oMxFiB08ZQ>~AGTWFbe zWgKxZ9@!=Y*MKFPUc`ManUImHcK^zdFj4-8`x8v--t4IEcoF*qH8(llD#_x42}2c* zslwjuJ2w5eBy{m%b)^aI%&?2-hbN$%SW@YirE z>@gq>yeSX5oAMy@a(D5w)AHe#d;S>$*4OO?6x*l5%HwKdxULPm_vY*Yia8aFDkM=4 zIGPQGBy*>rkDO$Wci}A=fu$oCd|eF-d8<%*-vc{I`#c)e|~17D+UXs?8+c z-sA_Z$#$dOXp?}?2N1n}Y(GqDEebuK5&s(|GTIsw(Ex#p92FZK|5iOuxhk!3YKmsS zm_^R9=Pvod{9wYFcNEMI=JvP{FS5e+4t=L3y!s3Lu->ET%I#{Z=%SI^m;6*Lh#VY^ zIWrV-L5n43sa%=8D^Zao_*WMMJ;$ji#QV^_UwZl-hy0|3J%Jw+^){Hn8^KEH*Wp z!-bQ#-`8jZJ6F98=6kNSQmRYeFH07N4P!e5KYh%;XVbpukco>UY% zeAHVg@6m!{vDOcm#`V!>cq3|Di&LNFS8;Xmq?Lw?v?jjy%*6MeZ@jnqPPH~Do~v65 zi`Dy7`o9$q>$6NTAC zKkw`CEeX2`$`%X}X3e5Mic| z1@la+Zl0mreOX(?v&9mXdnWjV|56%&CV>58=?Vq_1TP7BeE2_8*=rDD1xxD43DU;xqAPl@9ZhbuD@3V$gu8t?GioZ84`$pYCgS#zjMHHmp3iEm}$65nR| z|C=yrF&2So7|fB(3&kU*7!0%rOyw*^ki^JWSSKWb0h*5Bn}hcu{yL|B(tk% zWFx|}fSCizIvTJ9^qFE0xGf3?JuGNpF=ZVRaMREsW5X)0;ZsKIV3WFr)`-AsqM2wE z5pdS%Y9G|_Z>w#&)yuH`?FTtG?s#<~eLmLCyHG>$YtDXk?tHdN&%Gk6o=j-PClF1Uk&%WfLlpLE=Q zug%cYpXs8_1vaXd^LtzI8^#;{Kl&>HB0V^q+EHW$Y|IXHA0x9f+UYOm8a^%Ttma;O zT0Ht&G+2z+V5zw=R`2|%!OOfK8L)L-AJ@Y+E^3dDLET~{lZvY=N8nc{SMu@7mEtLN zDhgro0=PU1sUSq?RJQR!79_;Lo<4in-T3Ga6lmPrpX9GjUZro)&zrKHe49nw7{&b2I5paEK!+ALKQ%W(1QHYvLh>6I1SEZdEy(aDp% z`|1Qu9Jb>?ne$}!JvvHkNe8K~Ed(|JXIQO41{73^T364s#OeM7N~CLw3|BuKIvvAR z-{e*&NC@Nj%r0k8j1Aj>b%;7__UE&SdqkZN!2IS`S^Fblf*gfLkZHnJv8tj1Y?U+m z(by{OuvMN6En2m6Rkfk8egcSu?P<<(2~2+*0IH}~1*5-erQLXZXn)qvkD;igfW?vF zFtbJYZCj{x98wmDBh3pF>9m-HI4zt73;|?^c^(MbKcTGVkas zd;;C=#JNYkT7Zz6aAa|E!0FN0*=YUTOVVp0^L;#ym3l*PJJLTHVL?f4Nzh!R4HcA* zJYwLq3$wUMUr7mwY8%hGvyI0$cBS^7eZy@e=UZkwxo_WWBWfXGocO~H(@%uG$kJ9j zj34zKrl>bf(hpnSO#QWiOkNzygQQS^L`y1|=uazj5fQbu2?^Xs;376ceje3ceLXuP zEGn<_D%sGBK6}xIoZH=DuV8zojNm_u0?My|{mRcjZ~pwee$M`5+T&HwB#7G_uYd-8 zif3%r|9t^KRh-M9Pvb2rwuaxv*7RmSBvKMijg7ccIl{nnO=L+KyRf!k%+8elf%<2V ze|t>ngF2K;+!ps=i1r(YYU~bUaZXXr^kqeD8OCLcXc!C}#AB!Zk7>wwy@_pQYw#Cn zz2Eo&bA?m9qGlvI3-r`B{u5%Xyr&%Yhn^@j`WTErku80bjkcI8;`I`;x$&!F%qQk( zXIsBI5#PW1!L=w-iOtQqv@pMCxpj1QSA`9w4=w`=>WSHD25Zvp>|C;Z_R&ZF>*qf6 z`M>^$vuz4%&koW^K!Lg-=QJhLfp$sK8$8tm8ZYBskEepO+iD2PSOw{o{(ltw8P!L# z20qq_Bmld>i%E8|KTIEpX_ix`U-11Utg@Q zKI(09Y{7-5JFs7-1frSoM+cW~#8#hVnc0tu-QM*Rj%_G;(Mq7+{G7I*U__?ZqYl4S4cvylpGk&C~uBVfqck)%SG$8I~evttCeOZ zG}gPcLtx!5X_7<{&ejpuc9%^HZ4Tc^s0cmRM8i;FfEj%oXERM=(93QCGO2(df(Vm7 zozIZ9G_dI`5%3@`379ZMt(D!RJOU3`dw{`vB|89#78F|mLqTcUxLpPaAq~Ts(2)&8 zgcY})TYWY*RP3R}jbeNRD!k=177l_}Cpnl_hm!8C?j2}OH_UTpWS%p{jrsIC^CVFP zv*Bqun}m*Ly+24kODIjy?DrW}HdILiXmmb>wJITA^`Zku(fD{d;W8=?KzIaV#l@+* zoPB$PTDSJV6|Cw!*LkNGbUsMmA)+m^5L9kf#CeqQC>G&}D@OtO?w|e5HMJs@Tl`8B zCr(ouRc`NVRXslk1KSNG< z{0qz{&fw?;XOJ`6+b?Y{+rUKN$_~-a5W2WHJ-Zaj?0LKYn__8Dq?Alw?ZgiP8A6E3 z0jc4N;3KPAz!{+r|EH)#Be;}+M(7*uouEk3Q5F5I^JMmi+pUajlx5GWVp;7UQly+A#wZUG^G~A;|Gm|8pzc=cU!IZ$S9-H~@!(6)gf?PYA4z=vwQ0EulChvEADl@3a>gGKwU`a4uTOjTZ7 z&E5coZIcpD-VG2%2pPL~d`y~FV_XotFs_>?4{K~-(1>ziH*@}7%D60`w0I|aI8jkl z)koLXR;7+%@nkT~lLP(FX;(M^5{ioFCDHXC6~eGr5_{Xp^agK>6=4zLvWk?Awe^vy zju1hqNh>Da*PXFV9kg@?;kOWjrPzmX13>&NH!eLZvOA0WMV~D53bYm4g%Pu*@=7e3q?s&@^71Vva_Z6W9ktKke5q%Q$}Uz@VeT)-AvyBZ*7iKAiUs4SV0lSILw^ z=tnFj60LlKdUKs8bL%|m@j5Jvh%y81sO?U`7=mMpNB>ap{-Dz)CM!cBkf`~ zLaXA37*OZ+a7o<(2||r?>4n@7t>R_3$x+9^1N{o-(Uy)x<0(XBg&92*19naYsHZik zn`m4Dc{sf>nA=hijDopc&SZJ@qkr_xhx7KKVS5D9@reODJS>4d>0t@)@rP}J90_j( z2*<(2E<)_4Hgwh@bTxS$AUtNGD%W9p-9-T4Sjx=9EGeEBf)|)0G{o(* z_AC$2zHHChjc02~czEv_y*Sl)xGJrW=-e55xX^rTPS@5d1C4E73k{;!(=jLq?kwm6-^x{p za9%U^XkJA`F_2d&pVv{9Pb*?yoC^{Ai(Z*%dJ93+siL?ecG{*vn)jK$vfl31f4A)* zxU>J@U<j7W>lU7j(j+B{M1WUB#r7N50Z zKcb2fY#MY~rY?JdLr{*)dtVR5Cqj({(L_5y2I#l-A*_>Pvp9nM1;(UBeyhm7bVY4` ztr1^q>S0<5s1%8$x&2s!V2v;b<1}aPYt0Q*!FTElG2099#tH>(FMxRt1syNIF)tK! zy3-*)+Y<&(jc`1e(GhT2*SupDbH$rdl++Sgb@wr0I0IU=-kg_lV52_;*- z1fQB%a;2A?t4g+c2_dJk&Q)H*RkN{VyO-eC6H9h@3E{1=WT%%9{u)cJ_L3K>l3iZ% z<*H=2m%#SLw{kDRhbNW{yyRF_GW3#rtCDNHiGQ*1pO9a)H^^aD2Z(?kGyhGnKc{tQ}eOC1nf_e;(sSxk26eUmD5%wsYFM;Ev1sO>~IeA4c(E{hQU_|2H2KJ zQp+m_Gw2*yp;z!?aU&-cyf@9-SFsJeDw zJz7jP>0^_c_Pb~rw2~@}&{FXktN<0h@)h*1HgGh!D#ZL=P;H5iAOH7^P|6~EFvt50 zjTC=6$IuYyA|09p_-K;wW|3YGZ097)vjZ6LzzwQ~T4t+{?I*8EX-yg^B@DdRyAddD zP}-7Rwj@1Ut2FmLoPlap-dOsMiIPn(jR2LcF?FP&F_i-vGO++M?$Zc^j5EPqz=j|> z^Vwf#a>bx{%pe+*f;^>PlzzEhO0(#da57L|dvLi?5@*>;wMQH35WohuJa*DY;2Xzj!e>VY~MYVAL5ClGt(LQbz}L4OaTbXKkl zoLS!Pl*iOdh&x(XnBfF|dxnO3`HT@7h*5_}B1c29GR9h>2LL6Y7`UY*1;s6XsZHpI zZ2k5iwFeZ!iJ^4$!YmfTjiCqe!d5JVBg0zah3!}fSJo{$Uf79+aAw`2>xHP!UN_&> zp73c6VOnKru~{SxTgM#~^lcEtcb_=(MDn)cD}VE)A6z-eto$s5LcWb3jfZy>tMB}w zqi;7QAL~3sVUJi=$ z=qn$uGis9ZwSh_ydyXWb&Mi08U%jC8i9PA6n$hv*V$$m8YFYJHap0c~wO4BS|?|*F;4Yz2_Rl?!^3pQU!LjQm0n@4A-IUSMlsrbv# zq4LasF@A4z!^ps^sEH!IhWL2$Msh2?KRB?aD~>HyJ^zlBGG5SXx=4#I%ElbdLo@T#zL@j`N$y~ z+v44P7f{}Mx0=!T0GSpzt}2FF+O+mlH|;ft*AMTBi-SDZ%#Wawd~!P&nv2;x2PuHe zihR)GzqWwZ;y+NTg|*X#e-y*d$vI3MId6#n)mG=jv>EOUM0K>YN-qs}VcsEZXHIgB z+Ma~<$co*z&jA5leyn4{0fq2%)O^0|=Zd?q=@p<3L&?Ngrp|z+MJ_H*Agqmw5!G|YC!-D%pNCU0!?k-MxafX7l8^~*h9ZdQv`x5QzeA?R^fGV3hr5&FM9~0*jZx+ za+%7tEHp_Iz|^b}41zr?Eek_Rl|y2zgM=+he$W5#RSg_dL^<$3cp?m3dtC!>G4M4O zUnpe{FMZ&G!Dt5wR8iZK#s&5M=^t8MO`xuVQYZ@6jER-j&@cv7hiU|UuIW3ZeiBJ*&GkomUDzCw5HvBlfO zNn;@$K%T*Ka12clKsIZmCQ~yP(xj=0ScZnZah;BDR{MWj{R$lz&6u5YtSHl%_vjQ$ z@?`eztdgMW@c_~_neD*v6u%EUT=*n~B;?=txC8XJo~*AwzK0ei3{hr;@hX5T$| zAxySYOaCja$KOh1%!QWZr^aGVTE0tc2PFFwPwgy`TQOS}-^J?iE4#({b>-q5PQ?He zcuHwE+~fRXl3Mb%LQl|W;;b>M>(Hj+c*Czd`np&TGz}HvueJ3NwNmKd9?_JTNbd}j z_LK(VNseStF>m!&BY*@Q7ka)BK!U1NY7kDo5J19b51lU`eQaNp?{`0TzA;}ZrO2!) zCw9VDgnQ{Aj={HeC(G`UAu0TJFLp7 z6Tk3dS5rp}$HcajchDyLU+(^uPj6LCynrTkI<;?C(|uXxYzDXcM<=B($Ut&9v9T8UWf*?1WDbH75HsBXx-??BZw zM%t8;!+P@(pb50PBelHeu04b2_?&g#b@5F5Mb26B&=aKEVJho2L^bPT#&tXXvQV0a z)W)R#B@5Aw>^ZfXH;U~+`LEprj}JW3;_;7YwL9)rCq+#0n3Y8RD$2NrcpkM*(7{3oy|OG40klHg;_-5kmYlO1*sTNkhE8LfKqLNu|)w()^o$hDlk6{+cN`7R=vs5i^Wp%1Ue$Lr=TKmg2ku+ zS{8STqQ_<|Wsh!477m>jc`QYbJ(sS_bUZk7=&rD!39~cf9ZI<1=DzB_>AcC44)e-WE`J zz^seDjv#|AGPDqMVg>0vLBm9=S!1b1GTG~KT+oLW|0UKtSEtr{|HMRIHmp3-TL?Gc zTVGNBKw>hRD}g4cTukhc>LrLBNki-)0-+W%o)jY?<7TJGq}7(#VL|%*DqE1)Vegc& z--(MIRTYUH+&5Z_F>iDt(Z|LRWg*3wCsJ^m*pWC%Mc`qoQVIv=KeBN#3_(Ew8LU}g ze$rWq2@Nmd+5bLSIt~DI5bLkHk<(+t;kXf*=Wr15XV)f!M0+?#KrV&k)~K-RF2xW= zwk>oY8CjaTMTjp8$Wn2_xLYkJM_o*&Q63h|r4p01=IeBQGd+xm$uDBhf-s|r{H4&C z-y>r4c+n!GH-XJf3bTKZwp%!V%jb8QU9}7l9qi_mt3b@S7BKswt zfb}yVn;|TZtTRM^W9Ko7LG}EeL5nfB`HwE)xsT@A(b=Esq%+Z+QYi!CL^KH7yXbJ} z#A1HH02i!72$1pDlGiN&c!-@B`pQqYl_{u1KZTlRo@G)wHYgLLUT-3KfMxNLijemoT5+CbD^wlM7U!pQ zB(w`+?Zs1aBq(+h^2415oIO0t3b|Q4V~^A-cP=6`iboPZdM6CFOkzF+F}5r_^N`Y4 zzBg_apvxIWQ^~%<@yhddUgaLSi`pO-ws5KK>4LU95o+`zK$@RjM>t8;J)$L^7^2Iy z)2Geplc1-FE1<0#e_E7}+nhl|AqI;2TUjPnEp#{Dq8=TAU8SCyB9COwhi(#b2vJ(2 zf}PpF>R|W2Mmzzb8)cM501Sg|E2g=e7RQ&SCHdT-tzR;ZX!lCP=d7v)mAq3;CT8#j zP9DStD-0C1R(eIZdV}g*%qdTIIDELj=^9>4Rd}KCD0!M9i$7wcuaL;%|y@aN; z!hG)XGt8fHzG((fg88jNn4dW2Yk$K;5kU#?D8$K3)M2KORXU$B{4(FonW9si7Ys^& zAY=qZ(`Z@57_oCW(f~{-5K2=P1g5tzu)E&O<|=L^u}mV=NF`;+R?=1cOWL{xP`c6{ zB0KYzVXK&VtJkI#`9-M#X^_g2S8v}qvS zu*_fIK>P0OPrqhSS`YuPWuKk!Tc2CvmN>U?VA%Ha%oiq4e-kNO##H-XayL07Aw`bV z<%6laIWe@U_+Rg6-oa;W8N-$Shn=&t{7M;UIfr{YhSSUG-F6MFbR_n_7rv6*J)FH= z!UGG(8CDkm9{_YpNh^_7G4<2RZqi_G=(|F)u0Y2aZ=LVNI7Z088tQ5c3|Nf$VCouTyUlQqr zRCzRnp)496D}}or&KO)4L1;$YSw8Zv)NQGGVKuqBNLLATv%m-q~gG0~~RgEt_(K?ixl8F{RyWc)0#M$>^QhuxYHZ%+1Z&6&7j=}=hhathWr-c?3Gj>*ecQ{9?h zCAffWR}kU*#UEN-P2>*%`Qy2h6kM8CMot9z-!V+jpPI}6nsQQhSn!PYW7S2 zR~HbMHnv}=Tg44c*b52E*Hf~BfHlY zYx*oT%JoJeNSZm&TODaIFm%`n!UTV!B9t3UuoA_Z^xS`mdpg!LANc8f{!l*s1~90d zPk&o>AIwp4lJ(~Qc<`}(n-vd3~W@IZ+c=r^r(LtlN zkNSTh9N8}Z$9qlkg+LL*Bj+c<<$q+@s);4}wpiy2&DX>3?0Ye7l2mtka20KHYH^uQ z=%jteaA$FZm9JNa_VCwV$hWfZsM``l zq1a=Fklo2~gJPa<7X1nfdT_Aa0MWHcFc?%-V#>SA5)PR?su+GTwVvE?EFw13vlgvV z5n&j@eox-RVc@9FE|JvLAu}Im`O0_C%?yg*6MQSn#i1ska zFDRJJxBCnfAj1jtZ*NwapvMFz+Os7N ztc6=4ZoOOYpr&eY(%eev(ye!BJq&edi(a#QkZ%`KZMTylho9EQ)?!f%Q==8*$WqI4 z`O*+MTPU=yy7^M*0o*iBLVm!eUILIbwYwm+rxRM-O^bTfUFLzq%3wFW<-4_+^W7Xp z{0A_>Pem$dU;42ORE2Fvz>ThW5QKi)=8S|H_;BS@&MR#3ZgIrn#UXCPew~hU&U#_7 z6dg=me6=EL^Ihs|in3j{(K%aB+S$5Gv)|stX1EB}l1@TMd?&ve{3n5;P&S6e8xhb0 zEuQUc&Sm!buww`+aI&0iQY&_L&7a5$IQa>}+r%eg9c||k8ZY9Yr9!fwW@~Q~bhk<9 zZx_dV#*~uphD^IX*f1_I{+VCY-n*$d{!4t8=i?YbU;#%+1ixcRbZ;DgYgbvPBrLYG zfYj1~LAEYvm_?Wqv_q55UJt@zG02y~(qUOOqPdB1Ig8LY8_n-3T_xCG8>^NFani}N$Idq+NY@|>Ru4>@Z^HwVLTZfOr6 zCz^BYB@~hp#_VAhUb?3CQaJ3IJ@Jwxx^T7+_JmH^wbzEG_<9{*1KGek*iKDK_lB>n z(APdESDb#JfFH2ruAUjZT)&Uc4X)Sc+4;c@Og?vV#Tw;-Z24D)f2dOJmick7X=#3V> zXNW!uh?z`oP+z+bZ7JWS&}8^x$S;%Tw=_`3^Y2pB90dnzQFGu-S9h_&PRwcZ?9}Ed zdIFHyff-KR^lg7(u1_(fm#P0w;DhaN@eJB~I+D!%JQ|+m#6x0nzECaOmEklol{i%Q;NY7WPS|l*mQ;Ap*s>|{hOxg5DmB|8WpZD8^vQ(II^Db9FgXaP~vje!G5vp@F^iDNZ56pp8IF>T{#H~ zBo;yGcdf9ZrfG7>nEYVQHg*PFse=f?FG!{^q1z>Aip4Zw&q)y{G4$()12raFk}2cb zeyRK(=O-+~cJX_8v|Prj54rlLF*bd4k%I&4v2}Z2^W%( z>w<-89$>TPETztJrxGfZI7c#?gbEc`Ld6{TwcZniiiz(827FG*pU@+!ZGe3f|4tF+AMeNbn? ztRj1NA!_^wQ8R&2yk}%0oEME7)nvp=VIc$4fTx7{^eQ{dc6_&%+|;*K0SUHqyDR$> zPNRePvf;ZmhBpjo1YV4HYq3_xNS54~w7{F84u(fJ$s8nho%D#d8IjvKYs`*w;;k8! zM&a2O<|L4_tTrx-I9a0o?g0QO{g0$7m_H=sm@+|F_6nmU>^OQR(LxW01_XO!lkKa< z<1Y#VCD&*YRaCqqPklE_$6UyP18+zEePlhY+mf_pVg#SCc}MoqX6UVepbH<{{}FRA(TL71tn87MGReEJ-U89NI*2}wqt1w3wsmB)IRou3ZL%|E4l$=W zvdOkf`y1BNV3ReSW%&S`tOuCVJ2u&N(a5* zUOQi~QXLxh^WGcuDqzD4@q!`2cI?u&*S{`hp*$$#h zu)a>|F1vej@>T2rr+n>X8MWtFU&(wU>npBK)pN7HS_Q1Hs(|%%q(bZg>#HiX$0~Rq zJj%kO?((Shl>u5bVr%(GK7|VS*pN(jci-GPPvYjhZ7~_SPtRgUY`S>6dJRk{Z^Ul^ zyK@$FKx4+-shZh#Q#9MkU3Pl;+wUH3z6VzY47FPh50%hvh&fUpTb1Vyro-*ui+2yF z4-f6Zm4`4tE=AidMjyA`#)fOQ+rd@KL}X*xo2nac&2&3`&u}}dhdzv{<_y7X#hVTf zH&+cuYw&Q!d)S&|6O4uRZgw!tO^3;4r$#UsZq~jv4^o;CkCuHvDt8>d4xGfvAtPU+ESWt<+0+_)Q^ z8K>=?Xq^84+j|fAsEV$C{FdG9CYz8AgqBe5hL%8jPbg+XN1F5!NH)m^LXzFEyP*dH z1VuqXL_k3)0xHD@Dk2IB0xAM3c9bG0R`3xk?e{%%@7>%q@bU3^-}m$X{1+zop1D)c zoH=vm%$XS$3ygynr%?j7IL!ih7pEx%w60QfYHBD#=EFcPjOYs^U>kS@Ne!{2KT8Uo z71p+#s@sslVEu?qb6|){3ru0{BrMuG!rEgx5Y~Z4(1!46FByu9!c5yGPymQ~Rv304 zk*J8|A?&g-9o-=ajTeMPWvq~U4+iu@1N)#^VdX}%jUcF;(bh_4C>gpK=mYe~)``Pl zASWjWv7#Y;@j)90&kxh#WGS*4LRG@?2%-@lpUOe-A!97CK|=kSmCweh>wdGac85oK z7^rkqfIrA0WEdVwmP)!s^`5*`+bzJ*H>Ltf2Nu*jD?X82|ZL2bp`t` z4KA?iQ(Bu?fZXClinzcw7~GcV(02@yr&fm?!Ow!h0-aqE79s`Vs4}!CTik9ffdfdh zq?WTt{-TBok{ZvFn$AKe0bw+fT9kubwl0?}<&sox3C<*~JP|l(qj{zvwMD1#BcKr@ z3qL7n7Ev6L1q6RGkO?NTU{PRSgbLH#s-4toQ ztFh%MAlT0sX#Z(y&MHR*u>_IqN`$gUODISwlxm930^(rFp%aA;!xRDj<)~|DIUUP} z4#$t6o}W2u)+n44OAQhTeK-{pCkPR*YA*RvIYm;=CyK*Bqn_NcKT z5LI)5!?aoKFy;w0>>xTiPs9W3hR3{J=LUF>7)SF62V-rC4xb* zL}D~665D+W=D zAU>fEv-LkEBor=O62dy+jg;n*wA#$E;zu&ALL^DGoTUR?dpR8`QeNi3gO)iWNx>Ga zln2WGs^+smlCrd?$Rc%h=p?WQh?Y&;p-#$bGsYmc;t@tv1PY?h0qg?jNn!0VLbdBF zg-Iq_ZDwb+wwD6>(zu1?j`m2BWrs7q=)~e^^iGU(9n|Fx);houdBX^Uru<WwHbJrWQnAn5-Brhs1S5v9k3(? z2b2n=rctp1&3FuQr%r%ZI${w03U6_!4O9$}j2K6vc?PXX!!FJM=|RRWnT1f%L2~p; zoD^%)*ls9e72`W$&(Ir%H(*T~$CSxy(m3{y)+Hm@(irG6f;DUeZAgnC+_a;nQPqG3 zQWv46k+`xJt&`%wSa9|dtYW>IKm!zo>;pBetRKQ!bhX37(b&pbG@ZolJ)0Y9qk6tT zZB*wM{1>eNb^4 zmQmOCI9jaU%Ap)esSGFqiftGKf;6Fd+B3D2PB~sYLRLF5=F*NxP`)2Ef{GnMB!hkm zjv0=d(9sN_6CMR<$J(bItrWMT_6fUH`@}NFUq}1kL%mg~8`spQ>ihCy0`l; zW4xV;ada^$tP17r2<7bvA!<< z5UNV$omA#X1DJ-)I}y%15zadidWntggH~58{VkI@XWxt8V*tmw^-SDbd#ZjW(msB0U75nj~vLL6B-%f2U#?+l?H&3 z#2tBgSeL~FjWiH}qL4Izs2wPfbQ>6DhRjEaiPaqc*>YR`A^`jRA4mZaZ0Kgpw=N+7 z7hHleyenLn&hH7S8o(4DOyScd89G&V1@`JHQc0?Xh!!pTB)jq z$mT5C5-Dpc{{3d^_J6gR68>5TMP+w;3LjF;k1CHY4-5Dwf#gf3nRm52>0M-GU{mlZ(H=7DHHn!_q16E%!Hhu(w)q z^#Tp8&^uZup&QCOUD%ijDK`pCF$zt^W<@&5N+JTO{_5^yk@Dn+WI0g9UvDvDf0!O5 zOVww^C@8dNtSFfCX5uXqMS+0COxe(s5C&=3t3Bt1C_~*4kI9zqc%Vrm5VF0LjuEc2 zg=V_{BeUEHZDV#7E<0}Edj>A^8F>UjSWkIG?565`ePRQbn{xe{yv)B4rgkl8x#ct~k6JJCxuh*&9pypm zlDJ1fE3`&5ti9>%8Q5<~;lL}Q9s{RhQB;S82Gq06R1NQvtta_n3=c(HS-I0;KGC?1d9zzAht zL>5Az1?FpBOpvJ^C*gn*E{xkQ(Kdr^SaqY9eqmgwg!uA##HKd9fCCX}uQ})vMiXJ; zEJ<8|*Ez$zVJrxaqe`qB*5kMXs~)+slS-=2_AtF8R9$pi{Tvjf3{f1aLXs9sXwOF= z9xKj+shN;`4i!6xr(!t{0~TR64*1xxiS)A8*iePqH3nS29!( zK0>J587;g3#Wo#2nF>Y&599&%_x z$N_fhDWcY_2Th>pbQkNQ4TQ2fLeL=`EO#r{o8CzauFwTQ83&dj3;lth^@V-8mU4RPw4rn-ElT+1&IE;gEgc!&Kb9V0yy0{G( zrZG@8;c8!6CnrlS;#aW0y3>NKmN+kJ7#OJcreAi$FZml6R>Ec(61Zdx1^zK(_zOiR zoXEvTSCEU3D}3uJ{msgc_VAWJ{1s6jl8&vD)cjuP^@p%JZUX9EiTl%Tx$D@S5{jLCRORF+xTcwsLeAi3|fs z7Am*XCom{By$Tm92nIFMc`XJkeNc232D}liDY7og0?}$XPrWt?ofm(Q3bwpc^l%|R zXd!V)c#$Uyj`mEJ-+(@~yMT#So+5UFgSSBK)@=+}{0+R!uM*LdEyh_2(9*hw`938N zY^`{@6q$OHE)1s{fq2pR(No@`Y#}vqrq8QmMvyUsIA}baC?_9Wh|;qZa0F`@PAkI_ zJPzza?eVng*c)8~N62VBSrU6$MO+z&jDQF}6bbowtVZ*4DksuqJHlkfgQ_s*%@BkP zB!-5?47Gw446OoPHZ%xN)DU%KOwGbe)R9?KoHR%*5!uLmvI<}36*5}d0|7`D`|Wt- zO@#syc=Mg~mBteDUG!$^#0eSH1nXEcQ|SoWNKj88pQu4pzL}bG){TtgC0Z}j(|m|n zFC#M(rTwT3;+-?E^S<-ydn`)ShE<79)8bWrh`<{tFk^G{$7p_At^!L`N$9LtH3seD zH0&~yql>m!sV~rhJ-`RC3HY2~w|DuQAEVTj<#9@09vm=Qv!TSgoRCa+sL7)WyN}C? zYb#~UW(p}nB(Q!?zL^I~4*+IRYASL#`NckzTd;;JS8Aa-N%etD&_n0}D`fwm`&cVx zUjF0JuYP=N%OBS{GK=+Q|KLBDJ&jAq)Zc<$N8)7gBbt)u0FlJVHfIR(C4+%w~ zuElO7vnqF#5i(GJSbCyvlny)TL&y|mWNiD3$Ux`)7cgW^k<;13I`6`t;iYz7eAuTR zx@|Ipa3qx7d_T3nl@Zo0`tkGiizXO<>0C1+1=i^F(9y8Zn3Q=b<-tDDbxJDZ!eM}D zJUY~v$1p}SLxGqeyO98BV&|<28T3X6f>Ja7oA(faJhXBC*0lnxSelIK98vI^DOT?} zq9`{tIZVxY8JScMl}7-vovU?4PU(uAb>H`B8#+6Yvtq%Oy45P#2beNHDR*fc0$D}M zre+L>><@xd=iMR)ORJWJsAPd&LA_3tSS}*5^nE`fPcTfuyj705UUSqa?!eQ@QLQ-m zMjkEJFg8i&*CY$iy;-8q zI0_#_La_4Dn-xZXmJJPuEEALrXE5?6a9Z=5GKw&Kxxo(^r@;&YgRsi>m<1Yf9*c;> zn{?*&MCNqtCqa~lJjn3MAj7MJ45f~~hq~+VkY_j66VxBx)vk&! z-_w^6IT#RUH0|K41`G^03IQSm)Q+aiwcfK6~_!`k{BWAQUr>tcE~`JI%q$} zBYi5Pm4m*-%3B0TUOf6c`O5#8jUg2R+4I=k4UwNFo;-T`eiD6f;)9M2LS$cviYXL8 zvKUG38XsDALmFsbWCVX$M?i$bgE0^ChLoth1L>$LlQv8X%~hA*UD6E2f;<$X$XGX5 zhGK?63-KZhKe+ks`=9m^MUjV?&c#YXCI%?*QtA_k$c7_&u-h?lji*}czy4%7HfYkA z;{{Qt_c0iK{Y?G=4Fb(U4I2eF_9Budd^$QpPY_AGV%0;lCJTvH>{3#YhFN5D)=sDr z_x2O$*U6mR=vFR*+fN=T%mdKNDkNl*M6nNYLl z3xnBPD&G3QhwiP$pv!t88+5baxtK(*WMLEwi5s$$g^BQG2$iEK*LsRV2Jw|HVLB3f z@s>&_tb)HuIz{>g?S%L@Gg+6>jNbw}RL^w%>sbCPAqmC$1`!c;w?vbs&6T<4nyfErz!u0? z0Rs^@)MQkn(>A_N1(Au;C_&=T#zE68)wL#Qa}ofos{n>Ae9Oy;UCfj2FKbdgC=VuI&2tBJXxTQg`P)!X_eg7 zs4oh1vAoHc?Vc?juA$q0SyVtZ508{ z(00{7vfvb=>U`sXrf5+RVI*hL(UPXjph&yN^6W70#AFFxdpb+vrUCq;m7Z5Uj5-&$f!ELEfbBH1kx;DIZ2=UBf)p+}Tmyg0+Hqwosz8Aycqk zSfptVWyF+K0Fu(&N_Z0ERW@BUrD8tSCRx^pWby-rAqAQ@f~@dHGp`&~2%_m8iXG~kiZ~b1f zLGmpMWB1ni(q_t@0Y)0kc+x0HGyvjc3+p=Kl-|`-5#>VNf-r%_eoSzjXR3WROM2Qr zNyWg%MHB>w@zf{?R$Xcr1p93!Ask967e_A_hfbaV8nEnBEf=J0U0TgY!3IS$Vuc2W za#A&Lh8c>hHY8S1>27oc!B7F*k>UvpHcTTx(?Q^YCaI7*IEu-cp2c)(jySsw20ie1 zC~tUKdBYkR48VwqH|eCA+$2xy1uX{_CV>L5MchIcgy`Yq`w%EE#y&^~@FJznC<@~y z2+PP6AQ1Y@nRKuNtsT%1Yu-iS=*E#S+$xQ_!Ma8+3dJqYZ~MN%QiY6R>=0qQ6$48M(dWs$`U zV3(UjlXD{#b5fWuLjXQPDa7uWwys-+fqoKbF3bUm{m2c1p8YZ8p zP&(g&8BC@bN6d>P24QK!W4(kuak!o!j20*GCgSi26b00RvLi_okn0a;B7yoi&C2N< z<`u|T-ABqw2Q^g%^Hl8xm>PiHwt~x5NIYTf0>#!%%0$Rl2Ovq@jve3Pd^#w=zY?V; zpc3MUT82vxYRWLBN{Lvd3G`~#yu?6ib`S#|SOR96HKG_1e?VwdNGSCp1dfypOzj3t z$mD_M(OJE8fuc!wX7ZJ$<$P7Xu{a}Kp&J~Dj4jeQ7keK`IUsx;BL^I|ie-CR{)Toi zLI}os1X`Q!6oImklqSHWsE{qf`eWS_4=SmT73V-m6b*$yIK5md^e^gB481(qZshe(T6H8q4sC~3wIm~JT0goJOQ zX+#K#6EdjlVpWDg)*8u}s_U4Wvx=*&sUs}N?TQsCl!#HFDxS*%DEzg)UePjK(J?CB z*Sjznh81y^iMl@M3y3LIP5xZwt^<3%{qoFLe|9(N;Awi{FKQOmO#Yg3@k44*pux`OJ?e@wP5ei4#AZz`U1p^Pao~AeR5mKpIc);Q5oB^>P_XaRvHChvf z)94N98Xd;-s_6~c0yZ>-UcDijp-#P_Kky4A&??LxmL1vYVx{C#Rd(ig)Pj*@1?t6d zzcjo;V~Jf=U~h7hz!U*v3~sPY=TJfFHqERjlp55+L^=l@temkxhBtJ+9{M&)LtKoZ zN3L*{#f_OzLnT1Iq|?{h+t3m@1}}`8QCyI0W`lPsBnpH<2&ZI$zIf`WH?g$=CS|J@ zMQA|pfN2Ye4iigSr(x07=#J6Rn4ktQw{b(8V71)UsEy+KQ$<> zVk1!;2_$t>92@?TH&b?3F9UL0NU^KPPa^RPNnK&A937B|byZaul^$p`zvaYUZUsgR zss&T6Le{om@(z={sU^508X}DGSk{7Up?eWYTpSyx@D)t=Q{ri+cTAj+@lXGgd;VY6 zEr*lvPK36D)bv&;8)~)+*+fu)$5;S!{Q;J-03;IEXje6b`7A(S{Q)jNPGz`BfU_(> z!}?Qrmj$><8Qx$4{OeC)4-0?^T79+H#sb^~59?U~lI`lj!%7ywul@k{umAz|2dKDJ z3O{cqOx`4guUUYb;Ne3S;3k+nzyjQ)EnZ*&8q{Blbu2)W`U5Oy0d7*ryIFvnpn5I~ za1*NjeG?(-Ce8f=3viPx&fY4(+blrS`m4E@1-MBycibw#dKTa&ZSfEba1%T%VgYW_ zST`8gzDXf3u>d#eyq~iGjq1n4dn~|BP<@Fp`I`iIgQaj2vfq8HES_fp>M-_Inb;Hc zWuevC(xgvb;IB{MuE5o!s?nFm%C%}VAf}5olG8(PrB~Y1_DXTKq!bD5Cm9CSulBml&$(M&~iO1ydv^=eR zvd-xZ@@B^9RZGQ$M4DeW5IDMCRu`aLaLQVQ&3<*jrz$7Vb+PnrA&k@17UCfZHME@m z1eJ&g0V0t)MTIw;S9$|2uOpB;or5f>7b|rOvk}AV2Cb%k`axYqAi zWc4!fzh|6COQV`Z=!$ZXsOFk5nvU)+d{k<*JaQs0PhOQN!KHzTr85nwHXF5 z6lqWnhD5DIhMbBSq@u1MwnIyPtT(AjNwmO!Wfev3-}Nnw?@Kx1UM0C&orGB z5b>OPtoBHIhE7C1k!j|DiCVfeT4Sx{c~nqzK}1|Cfx(I$nqsDKW@fptVW#u6KwV_) z&od=5H70hPlBeh)BWJ}R9xZ}bT(XPru;)??=yfb<8hgV8t9eQWED_n7jg@En2@qDz zk}2+yF8G0n9)Y16+7V&~JpN%stC%$z22n27aNr&?@1f2L)$!6T;6_%9btgU5k4Qym2ISVL2 z9dBowVF;bTG}qf=6f-2z!ilU6B_f7W2m8c8}r^jIxG!}v+QeW4ceBU9@ze+gG18(6zw(LmBo4)eqIO{_im zLLq~`Dk6EH6-LEwJ0l8 zOHCA77a)nLr5P?b!Ud&;l;nm$NDCGmsRAM@prC|sN}!B@o&h-4Q&uFi9>dIS$Q}w+ z3GgG!EtQ6=_ZSsdPiS%F#o(?weGgajReQ|Gf5BJH?LxJ%s&BRaNo2`NZ$S;bJwPl1 zIZAXrJ!+)Jt6p}_v|r#2veH|i9kpIkrZ(Yghc!3Wwh6sRNy)+1XBxRc~6lbG1mZXh-^b4PW0{rN(2b5W^IOzp2(3eqBmN^ zLp-`l!Gc8~qE#O;18G8uJB1AdbkeSeH8>Mc(W?=b#6IK>s>Xscr4Ayn@GK%pQ*!IG zBsHNCmK_d=o0G8$Ez_4EM@DZ))e#@OR;epyKUAdZb>&Pi@|eXj^8brSloKWFRZmJm zn~tiF%z-vZDGbvcTj$QJG!|O~RwuR~P`xI^8eo!K6-!%%+PQJ2ekeC}Qi_3&CuAUH z(msb_yrhR-T@|%Z&tY|EJG>EC@TYdhYF`nFQ=-Yi`^=V5ALYDiGzPD};(%)$zd=V_ z<8mcBC7Hef@|}%a{;;ITPFM%IVa3-M$1O@c?!1 z&W|&5!#R#i)p1;VJXJUoa2Q~l$73%k^++D4RvNf9-qrLf5Wg|te;VUx2SPbFi#Ky4kbb-m$2G)Lg*zHKuCoSC1Pn8CF3f@E zpPA*!a%DNP3bJyuva-TrTxD)gUJTkeKQ1>uHaFK6mzJEGhqjL^$V*I1j!Vu@Oi7H- zi%W@5%1z9TDK5-)*+46KPM4iEf1$_jim~O}O7V2Z*d1jhc9+e=Xrh^5=Efr5BDf$p z6^_NbFWleF+g1$nWtmU0<5_CY%Pw#^OR}jb*$%tgW6x*!S&sb2BcCKV!jDaI+b5UV z9eH++lK}g}fjl`29MNbSxW8K_FFt^Pm=Y%|K)7h;ZbzEkM2^$rslt5}*yct{dJ3Hm zslZlPY|l@ZN(%F(E?rT~;)3X6yCXc}KQ4~DxG>MI6zD~iX8_9a6$(T6SK&m^Dd9(j zvD22p|4`;`r^|!(D7B%kRNHKuC%e#*Z=WW~f29d7J1E8_c_!K%5~@9c*g}ECiY}pC z^K@peIi9QWq`sDj=RiDX0FP7;748d|`lAXD0Ze^Yg<-M4bpYHJj@q4EJ2>K3=pqcJ z@8NLtqy8QN*O37H2qyk8++m*vq63*}N?YhCE%W^So}TM;xhF=&MyE!{D_m8jBDq|Y z|3Ifl0_{t=(>->#1f=B`I;Pl)K{NPUW>1$8=0m-i3&d0CW9CeFmK3_(g^meQL7}}k zU&`TrSH6!;HM9DtDJW>?n)y_ZpI=rA3PSUEQvi=g80ybz8grA(+(^L0KMDUA`pWPP zz|=kk$a5&3*WrjC4o)|7gYXQ*cf#r4$C|@#b49uHi=q;uF(NU<_l<47gzv?NU_~sn9Kf1`8c|h>k(g?(j%%53w_;2hd#V zvQH^=mboQ&35Xf-9P&VBpJvZ1V;vb}TvF&Dbd`CDq^OuYnyI7y9@bO}%H>vpwP&oE%SQNy=n5Hi`1zS9`p zMF!dTu6XaJfp5cmh6c9cJyQb{t@O~qJ@MX41NX*z9}V0W@BK6|jZOVEFpUk=R`jFt zQ6C*l0Dc7D0ats>VuMw_J+H6?GA4~)1FWO6M_Bv!?UCK1XZOAXto?_QV2S=w?3Vjr zxu2Phy~NY0tyQ=L?=()T@Ep7oKi0xjXP3PcLkfl!TVAm}yD;BVSb{;{R#IB(!eB=w z!~l~Ik+uv%rj@|K^r4oA+?V1dg$UguHjrD8{t!5IJRrWM;rCN)=)qtLjQWY;c0n8( zV~TBVPqthzRtn|a&HSlzW#<*!3QH8(wU8uf8DmPRv?XNkH4BG4HX$#PJ!PJybOdlL zVl9OZjIE5f33&JBJq6^*G4yVH&9)b4sH=_^9v_x%P zPttN~pbvWqI7z*!x}7CRRZVj^(xWt0c#HxMcN96CQymhc1kLv>yl24GQ-*5QV{yaV zvj-|yXPxXwOPhZsVCwU=)3?a@C&bV!XnIv0URBayW4l9=@c=)yPW$mrd_aZYP{OP5 zA;2WZs_?sb&(OeMVAbJ!sq?1veUw@K5qS;hFgOcsSzCIdC?(T(~^Ad^o~g0o(*Q8vhF6 zCczcK6~hrPaKJg?O5rBMx!~Mz7%sRnxG8W`;ikb&hnoR66K)nj`re=csb#z7nAI1+N&MP<#cG$BJ~?OXkc`;9?eoLCh=~%lxxRu zs_ENGQHjIV)y+wM0jW)a0CKC4b=Ophg((j>$i26UH){_3}rr^EqB^_GE?|=UlRMZ?=s(xQwNoCL1v~isN$0>e;S`^ z$Eq5NxCaoAc)dKaB}uQiu%xh#oD$TW+}t504pBxS)GEk?TZlAtin|-nd*Bwqkw5*2 zMmxc&^ZKf}waYd&8)6^He6~_sUZH2YR#zi6l*@Mw3Fr~uCKWhcCD78)WCK!hA%>)q zQdzoVqY&mRo-&sMq9X)syUXQt)y}e@geHpI14z3W(i|>u3w_WEAhSx?jg9^Jk*|V zF9tb+dB&=>sip|XFPxqY<(7?Ai?cP7<%|AEi}l zvkgLl|6Sa+V63$y>PM=W^5a`i+MEAFs^f>1kAHgkkK4Wx2NBk*|M+eXM*BW=O1zfZ zI56g%r_J}j9DCn*Qg`6fXWrS(pze)92MF^wA@ z9Q;L5siWVqz>gpNz%lu`_Rka?+}<|1amz99XLe~Y>_*-`_wXZ4FaBZwSNNXcza2VR zaq#6zZvL9YV$n=m~l-({QNbby{}H(P#m2?=qSrquT> zTAAl$gWHAYN0%0txtRzc3m~ZLkzg|ygXe2-)OITT2i|F%RN+7I9-x7tlV$S?^?QKQ ze^mH(z^ygm?SQrMCj)M;`91}(Hoy6RY2I?GXGmA^SjbneT{&_cAote6hYvNqUb^+< zl@kmebaKzDSD&4FnX;Q0>^j|V$lmxcA59=)nEpvjJPr&dAa%Zx39Kf@Ss(FQk~zfSo+n~whTU$KCj)|3p^ij*CH8w zdF9@f?;N{xUFfw$2A|*7vFR$m#EVJSx-j^@=aM>JnUMP2;A=e?-1)YH@0~hvxU%S4 ze+KV<=lzflJwAV9!L?xwUh!tTmyfP3dSKnPECyF@$}MkOyzR5y*YX+s>!;ZPqYAb@ z_QADc2Dkrd{}&JZe)i{!*E|f~RdHj>6WgDE-tYP>1~2M2t5~0%dsn;bl?)yl`&weo zjXiJPc6~8}hqvE-|KbG$SB$y7oWZZmjwo$A^^a4Y>uVUiWY_s!YhO9FdCB#S3|?OD zS$Hh_$={#6zKy}hRzI=ifzlo?9k{-e!9|S&_x^s#c+aWpdl>veT%3J)yJz0{7{xgdl2F8_U6+HG@NF%HjhI~p6_oOyKRzEq~2gUpxp z?aZU`vzH82X7m#)zS+7l^}P>DxI~s(&#;G^w(l@#?LuV+-QmiC6LA~ze%PSQh@aSg zcyX%zi)UU@X1Jf(w}#wjJT(7fMT&j6<>bsiT8=yLFD9)*hW$Epb7bLwWdS^KUyl3s z-qMi#ANfx^@Wl-7H}&Gf4?R}0A(QtoctKJ5&Y9DE|CPm)v@4%5P(E*4kB%xgI|FYZGB7gO9%Y&9I?+Preu@>|yX(YuLY<{(N;| zf8hXwH%-fWfAvx6NP%#K!Ka2=X8t^;$*Q@+2?nRfwqAMi`E_Sk3nv-8V#k+RL*M=6 zi5G-(4DQn7@r|F%T7BiX@I8agJvKhxzyFk%zY{JqIAl%63m5O(y2wYo%HYV#k(LwqWprV~@`m ze|wLLMPge9M}59c%s6M+yGe{>@RA!n#>cFgaNj;Lk-^qoi`P8TG~vXjViyKK8T#eU zWuG;F^cS%QgFl&iYPVzWithq-{TW>6@LX%mnBXdOmyrm9g&s506+MYpl5bR)T7$_u zwRHE&pwdZ_hYP8T6dosa=^`b^MQGwbt;AQ;Gof@r@YAesS%GHqsflwMac){4Z8a2}oKfPa`F6ngPjyh?9KhOg z?E~Cf^Zg^hqIwB&G0g)DNHlgx9!whTSP!ips+fH14y9`9^9!*?i>#pU zrF0q zz>E;+!w8F}_C6nGzOtOU8tHie9M6V$Ql2`+t--Tv*V-+X6JBgD@JN!YaKc1SM2???3<^By zQcg~!pX^ER>C#(BvpLfEQc3$4JpBRlt>yC8_g!7*Abp>Tn;wWmc%<@C8dSzd;2wor z3n$@Mi=HvRiODT1EQYd;RG}WEAt5Zukrp@=j>S9GU7G0^=@%(UGo^B=Jlrol(r;`v ze5^y5adl<_xi5ai%h4uy{_;TtjCuomAy3`X8i2>X~#G&#(iYM_Jx3kQZhl0^ku9`2{6R9wm?ibVU zyosb=!sJ_?YgZ4t2kA6MI`861bA8ht>e?U7JTOP6)hbUxR4Q9o^sbT1>_aXo=qJp~ z)M~>A8aYB$^E}lfswde-CD~2s#vQkr*;QyC@DCK|n6K?tw zYy5Qd)8<$ST+xiZ75X5JsdeJ4l%xe0&270|ZOm-G*Z~Agd`JruJ*seLd?&u5!XfBS zL=!69rv}_tfyYKiM~@?&i`pZ=rK@ptYWf`T<+k#Ab00j3c2%C43*#aOtqM_>2&b0_ zY3fAqe!Q3P- zN#XLkcmykvTAn>ft3A>>iznCu_br~Nnm6rQ_$|Yj=FGRpK>6qJ*m8@RB@1j<+L@WH z0O@C1z^O3NcQPEdu;}$ZK7zr=Xz&g4Yhh~c9}-}05D=&{iwzq#@@>L5)ivXriy?+k zzJ<`bi6nLsqfF6!tQaT6^N$Np3R`qrjeiPP^w)&z;tk*J)21)FcSG#RQHvHYZSi@7 zz}x#@xf&gFTh_Sjvz7PWcmJ{{pWXfP8wcNf>x*;eZ*aPxh7oazDe0ZN_U$*W@;-dr zx%=gVZyh~$?mVXpXu!UvckbD%Z@=;R_R9NLKl0|$V*x=C@aj8qY}WYfeEYrkKZz)B zym{)}`AY#oJ^SX{D=MGc^XlFYKDzYN`~{0PZhm#|8;6b_`}DIut6q8M;L&4!2M!uJ zdVKcX_bqw$g%|g}cJRo+P&CVz3NL2HMzMa%5+*-t$^=jA<3nzm}) ztM|Y`qsC;7pFQXKH%@$T^3qSgxZF!TWh>f8$2|V@i+c|p`{>le87o)CE@}PViK90L z4jMDoU<@>Oi23oN!3rt=o=nV$JX!I5Q^d_N!&ddi14fTzJg89ZmQ=xf4 z3w=vtTYi$RNO)S@BODXn6;Akn;QOKQk?<*hT7O3PT6aPCQM#o2T>zo-{vA4Z8#rjm zqmQngx#)ov8=l*J=d(Tr-{h{{M*MvIU0raq()QE@$o0N@7{C3$K>C*W%_MB@7VnKk$2V^numn7>vr4M-(S4(#zCFbrd|8+ zgw*st{rV3cI(!5XT~408pvXO~e9k=^w>YTD)4=X?Q+%8F8Jl(PnI`5LePf&GEn=vi&q&qX zu8-0A8GH>HQU@GbnJlL3Lku{da&X_2gn$G?w9#*F`ym6vjUAhWv~LmI)OR2<=n>G| z;OEoF*ul5VbepxKPiMWK&mBIz-Yn`X7Uj0;WAv-oJU*w$Is8l2(DW3c00dH zpL!X#!noN25si!-_hv^kv*n_>X1E3(iFX>K)bB&^-VLr+(qzk*TR1_MreQbMNwz=x z0An-$*RdYpaOSdkRc$$&&DvldAtlzKb9Q19L_#5qS*7iuXXQrF+*un7ou- zR+{Z`vQ?C9d48&mw+ZoR0ybYKarf(UxN(ivaSfYFt^K8())yn!b?O)^MLIX1juf8A ziE4EvCz`u1B|my2C;1wGCYkrMq_hnD_5J6`ILpAsbE%|hct}`Nt zpAf7V}sYu9FAh?B)hVrSowB-BnIvhd9^G5y-UNHC@b9uqn{Jy5A08HMA}6*KTH#*?HVznh!Q{(hSmDcrFn)@t6MT6e@iQO+ zr8Q8Bg3-rM;A30I>0$xv`EXxR)N{BjL$3>mE^iak=Y)q$ak`m&a$p2%=_ke^MFZbeY^&#u z-Ed(=qAz+ppDhw1efV{}Xl%@|%JWV51_n{T-$)f{N*F~uQ7B&c4(0N}GgKIEB%euy z3w*VUXiz=p%L~7t)jDYxUcw=j*))EQ%G01g#i2r z-U_#k0Q?B1`5T$+kO|%pyBntP>FH&TsV-Y-ctnl_Q(~;H=0K5?Bin>>+Yz4T{v=mF z1xNZvdMEb`+<$E2%k00|g0DLUi`-1{fOMO|E^j!V_rg)RN%p4SKWd?9cT6dCIUQtr z0n76##PwBsK+2oia6903!l~ir;N1k536t_7OfN85VRk?TwmdtVbimXi zS`&UQ-f6C)#;5gkim!!R0v^IPRgi`d_90$#VW|Hm+NRhgX2g(d&$E?5T{qP(O@a}= zG}Yy#X%^`o5U$V@t)@xq&rLOX5S*!jiGH--3GSu&PVJ8ApSO&p2Mw$NTQuCv<>(WMI0nx^(U!P@V00Q+jfR|3|S2TR`7@>^Qt`?4C}*Vgz>utk&p z)*9cp1J>5(g&N;?)%gB)jqmT&`2IzW@26{g|FOn*f-Rcz-Kg;$+^t&qLI7*=)1t=r z_!{3;dw#V&de->fTZzvI9rk>(IYv6B=+G*Fv6MMre1yJ$$uDf2^X+OnWi`?vSX++` zHNJ0D@=@dO0Ia3M?KQ$bT_gMnz}mj{W{vO!Yx6%>BRs7uBx&&cS&jGvYvcb?BmVa_ z!V|0wZ-k7cEg#8T+IGUt5Ud@C4zmvH`HwQbQdq6@vcqh4B$k~_j`GclK_)Nn_}}M z_3a_6X_)BxkK%zD6<2MPK)%Sn+HVMU{1m#ND8&E{ng(?%HhrWevQI;uF%ZW|)19zy zAK246ExEJAe!Kr>P;T`*n*kTM*m)Tq{+jPKW zgREE$Pf3yWTpsMHu&bVkw;28bc)|dYmV>-sHo~9i2{RjS8hhYJ;~Fh39mhMB2b&wX zlXwTYajHi40$?henx7- z+K+vEqQGVA&q%9Y~pa27Tc!Z(lo8w?v1}I zB2}5v$;e}q(#~n}o-i9KP3`b19F>#YUbua5ufhG@OuaTy$TLQxCw>O`4nn$Lf|yAj z)WQ}Ge6hxNg6aF~aP*`8MPvEj@5Y55rwtpO5~EYuejQA@ftcD8X11*W_R>UX*=%o zXeE2v-+70gQuaC_6VD4%`lQfv!}5?4JTuO(iQRzb(pCrde28aa`(KLuyK@z%Q>O2? zcIVc8ykKPFlUhv!0W@3HKI0Y1kr zRrL6^-RE7Gf9kp@$&XzJ%!5a=O%x0ch9*ETgQCe zVP8+nM_>JUI_`4MZx^pi8{I9USKDWd3oqWA-K(iX|NQg29_Y2^&0b+&Za&;gob~ay ztB+srHE+Nnmn}1)_m|T2V}CT9*gLdvWcOW7AMO3@`X(LUKl)zpmi^XTzH6SL&!(*X zKSktq?elf>kd!~ix%$}Fojx$_m(6{qA8z*RhtHkt)4%-K=z|x7`aYV~{nCp?z4{(Z z820@ppILpg*6rNUq4L?j?!)WX#hpLjcS-tN#@XXT`#qdL`;7*ncl6tL?ei(`*%tJR zEq^e$_wL>Ox;Z{CF5Y>m-_bXN7v6QI?d{g9%_n`+e9Y}nb{%{+Zt&9E8x1%&rd$4j z+ehX+^3#CwKW;DCrE{!58PmVV&##|5_f1~^#?SoRa{Ref{X^H3ZYpbetpEMCg1ZV` z;(%Y69cStQ*Y8WdJdo=c(ECbSgO{&u7|?vi;ddim`Dnn}Rq4Gv+X4pWuRXW*@S@Ct zT@QW!;qK_E1O3w;TwM6)wtF`;*mBR;TU%7P0#jE!W4t*r~ zfyQ6#8=Tui_xr<*e;GV;xc&uxY{xrFhVKtLGcD(i!yOYxG+(*=ju}a>Z9TQ;%{z); z8}&9Wc^Go&r|4Jj3r!r7_SEhYS6JbYL!%>n1B=!UY5DO>_HQ=4Kcwxz@V$>MG7jBt z``1&8pXxT$zkK8mO{3gH2W4%)Fz)xqhvx10IJfNA&xf`uJv7dDcf(=r`lmg=XkzbS z(QEJ8@Kk2`u=4%O+imar+_0?6e>j?*{A!qc@~(SYJfTlphTUwGtV;I)TFE`Ij)Un064A9-_$&|nt>r!fi9o*Eamtzg}_vXJLfM^>B|*U)y>r(~V) z_^q=BwC$nG82{mCIZ?y)p7BQ-zBFx%&y(ZljQqOE@II%;KfPjbbkesn5U8{^7;9dyf2|WzOXxYZr~!G$iNQ4tGUw z8+aFbM|k?kuvc<~m7^=CB>gLA|5azZ6R)?oUB2>m^xf_(+qClAUP(H9zwN`UC6V3J z58C__cl`GL;VZVgxZ^V_$HnD7$yGjdey2V61b6;MtFYC%mD0uRp}!o@-E`sGlqcf# zdB--K?>S^ndfsabo-TS|NoijEgw?&K?bw)iJtK3}h|{0st(_S0TT-Ms|KRICd%CCe z$e*?&c1Uo~>G>m0?H0|E0}$zSgdFQS6BD%d4giEqb{qK5owNg+*I@ z=3M(?(yK)s^PS`07Je>D>S{`!y}v{8JpcRlkJ~w}_}xRP5AR;OtoYy`2Q$7&JXD;r z>-VK?glolZ+^f?^SmH~*8vV{J8wA**RrRQOESqp3dd- zeV#Yw&Tw{Z*miQy@@Je!nv}e=V$C_{oUFqYd-gXkJ(gB}e0a#<((Vh_^!QGyEFHFG zf8+KMFO`0?JaM(teX%s?bMCcvPqdjlBG?)ivuxDlqS5zX+x^0QlfV3E#uth4`zN2g zw|SG-um3iA=uc}`yRJvMPW;+^y+Z|T?|##<(zP}2&+lgTd&gzUp5?xGpx}OI z%Gl$vXOrD?hq-jGJY4KP?l~0p!s+#H-H_>9zZ~_U`_9cHSG2fj@&q6L_4CPPR!_4T zp5aH|EAu?M>fLYW_TK8ryYYJbv;Jp1UG}=?d_Jggnd#}lr%pW9uWUleGLwCCMcF>% z)PdKJ?JWE0t>ClQ#Ba+!yxxEN>`ZCO;%@6kwHi8XO3c8+Kc1g(_mr1yGbWvSZSR!E z<%>6T`sC*+W7fnhnsO|BYU%tdQNzUSsqN!mSreT5z|?1Ef4~2s^utrL9{oBoqwn>p zf4pwC9R4AG+OD66MWjDDVcMqHEjt!I@W`|Y0J*m>%4a9=IH}wO!YgIcyfB_wtEV$t_zy6cw|&XXWw2koZC}#?pZW* zhP}AWtmKquXUypx8LC@we#ZFGzgc>I6*BX)mFY>}9UDCJy{>l)Ux^E5_PV#z{8K%4 z&+MOiNe5S4{@4q-A>+tfU<|d_R=M~bD$K-7s3=b&yHOx z`BmG|nI#4$zY}o)gPr#F*hza^O!GDGqz;n@)yr7|!$mAW!SKk2^9Cm1_!d|WPM|IB z(3MstLOa?^NR0_&NOdC2Hpn}RtJ0Oiv&zUIEQ%g+y&@Dd#;Fr={DnluiU$VEK~@$@TN9U)gNe3&Cgv6H#?*Urr>{=a`e0=hX5Vr}0Y9 z={cwuELf@+m?d1-2YKdK#}{n%%$utg%K?qB3PYRNC1#Wv9?5`oDH2#HE-P`Q zOAy3g>Mh%{?8TGj`iJnOxq6j-7t^>f8&itvtr)^wMp&AEs^>(g7$XHlxbAqn;+@INf)Gkr_FQiG;juBN{`lJZ}zJ`8%KnHz9hN+ByRP+{+RzGU-qMgR6X1QyuSf=5KdidmGz}H*IK0BagN+I$bz1CSP8pku62oV6TjRB{(s` zHNE!mUVss*%;7F8rL!{Z`OZ>0mW$*9w(8?5!+Bl#>b`Y(#GzdZ80jZaOoy$6wjszK z^u&hA=`;ovx$|63w>v5yC*kBlD1Z+Qn=Te3AIyT*QRVY+*!mGA2J2?`bm-t^GiCyq zFH4^GI}qfCuH0TCO)hhKY+j+oZMP$J2eh&D=1tFm-4r;D#zw~4*qLmf>cS#4+krtR zf#j21pblrW(5k-6o9-cHpl(oH!}=OUbJ#soovtG6$^d}#r}D9NpsF~1q5BAJh zM3C1DiR&*{JyBnEe`%UJ}&+R{SoJ5g$tk7F>P9tZ9f z3)(3V>j;mkCqy_bK~t8H)f}jyJzsetQo*r4L_2C~nsvd6PKYQPSQ81E**(?Z0%Va7 z`eSENAz8>>g^)?*I#AwhGYb=Rihya3`Xcd6a&N=obQd=ooB5NRL;ds!-0cWF$W1Gh z9Q&sB-*@m$+ux1?mcpG_ho=qXQiR&SIM~6{x`iq)DVu1plcBI+I@_4ScDP6rolX!4 z*22(C@}3tGQ#}(2`KryB+mp}K+1~FMG)EzQvK5{JN3xI#|AdN>taJ>H)=?heu1SyCNOA1iTHynVvrX?V^cvP&CO z<{4BlfN`0sgK&B}3;NP(vCK!T%J~=lL59Pe&i-H`z0iq>i6|f*1HeK069ef^48-p4 z!8iyWGSBGA&d?&-q^Ox-58NfEoCcbQ$>LENIJGQ%0@^bA$F#8A1%^@0>T zl6b=y?8h2LtO0fDD<7HG1B^j=Wk)y+C2lZK?lzP`AI1u*vg(f>J_JP_g#KOS+e7WN z$h;>V?9$h5)%sNdBWa@;GcvKtowg_Ivze^V4n~(%^6r5iYekPmf>yP&65Q7@+zmrO zPj|JODlh1!R=Jld2@J1VyzhffssXEF0JC;AB_uEeVl#T^U~doY!8#~%>qWcFsyL9l zEDy&hxeLnvgF{5+@hY3v8r^IeNIterUIxOt);MAXH{R6y9K4e34bf|Vc z@Gq>7R9io+_dHRxEKi{jSO)W!Z8P49H~oECd#c@@&6Wol29h)jVZ(--*$!orvjdTb z3O9$GYN-K}Tn-G#WRJbMJHX7IhnC4smY?*PyM>Y(cN)qB}j$j-ipZ7`SAQ}As E0Wir?>i_@% literal 0 HcmV?d00001 diff --git a/tests/ref_exchange.wasm b/tests/ref_exchange.wasm new file mode 100755 index 0000000000000000000000000000000000000000..5347a8721913f6d090fd1d1b57ce173bd4f17355 GIT binary patch literal 561712 zcmeFa34mNxnKpda>gwF8>f7DHiG=C7U5QNRGqml9Nd}lPw?`BP9T`P`zWJ6ANh|4u zBxFJPe<*Gj!$2HTlCi$8ofvpoMtabn2yhuzj$Br7m=h$_aMsF3jRf!_)cRKq%!8@L1r)G6%%#R_4p z1%1$!kv>gqM=Bwl^1viKpgzFICrJfF@-5wA>wGEi@my3-EF%>ns~|+cM2fDX8R_Z| zn8;8Rzof$?1bZjNRX0`dkR-iRs6}T;U$$1nCjmoqq#II@PJmbk-+>5B)!oD!1s`8{ z%MTXpprCw9&lJ8S!8x_L$L(8iV0m%h>^ZX*_kDTplBIo%t&nLY^K;hxz6Dk*liK!O zws>*hf~B)&@4N59W%!;u$74Svq(Bz9ma%@4rZ;miiVg+;_iO`}NKJ@_tKI zQhCYJg^Oo@xo_68CHT~Z4d7p#J%9Fsefu;tCY5dV&6!p6GMv41>Fj;?L-HK7v1G0R z3_Vyhd+wZBU!J{0)m>b+1eubb!Q$Bq<}BQQ){?$Hjikbo{bv8uN2gii*^TCTef#b^ zdtUzcM?d^e>V4_J+4Gn6fh0?pEnc7q;xC%LVD7%wHY`3)o@Xsv`lT7_WpVz(FK2!> z>z^NYbu+CQ+D8Bs!6vuPmMme))SsS~3zvZD9$eD{0dH3lHp5i7h5^zu8Nq2f{5a z;OMz?WI z)Jx0f0x0S~0ws@xsE|IUZ}~pSk(86PLZ$GJEtL=0g@5ewyE-aeU4=pcpIv?jFvNfQ z3rIr^_#c=7UVsIGhYzfW_~1iF6$rG;k_ip@O&zvfvGJk*D*WkZ{>uDAN#E}%Bz3Ve zrje%+|ezC( z!<3d5ax<{i(n5k&w(ssPSEy~eE0yk!?Yj#dlRnbji64@J9Nj={XBYL-M>>(($&Vc& zhQ4o69J?lMU+?du^%9Ymqyu62F9JxFZdB5-DmGbnC3dB|YSN3Q8bLUPS z+s|ksiFaRwszNV1XLNS%*xAv& zYe&b9AK%fGtNDhCDOaGso5qQTg7z!m0UxgGHu+6WP1R3)(s7Em>oo;I$#n~k-CQg> zuH8L#x9;wb?Ede&C)G(+6`$rrIMv2OSE1Ze05Cfh_SmD~@3BY6PSuVAERFxEj!zN8 z(1w7uqoWf^BJ@+HRI5;TAF4J%EGrd=D^OVJKv%(KQ=omI5WBWF%+%ci(d?WAWVNHXd={j zDGgVues^~lX-u?%bpbRWoKp6w8-aIFy`#K+*{@c&N8h)fBpnd=k+TCtU>?bZ>bGGn zf(~@J+ya2`3Pcn%DQm&DTgfOS4jP962Qy0@w1$AU7Y%Q?~(L*L~wDJkB4z^3zk?n2Cd5$4+gDLMvo+< zG3%jVyehP0;rs*pW+j<7sKWdAEu9UgceeF#(7dE?>8yoc!8qC47&L!5`SC(90mHn- zbNf(y*@FFNFTikh4j@DCtrvr^@2gAu7GPkxZ1&s(^J61-nmQ0L{VK+M89bH8-Ztl4w+pSxhzm-_mw*Mh&- z1rkIfdDi^72P~UAXYSI2tk;9_h8(Jg8vHkc@qp)x^ZRBk`O54?vle5#K8s`aH-q!>upc>|U>x>N!6F;Gotcxm$nIub5{^L^9fqjdYU}S5pE4B08f@S-E5kZiJ zUjp|noWI2SNlB=ze*CmlWFG#oE-bb1S))LbE-IDGYeD(Nr7-z@;KKRK5bdyjRvMqA zA(pVXZ`Pv4a}mV&xvGx!%#!pa)+MEFlB}A?Szw9v3)POs<`V1DQoxJ`yO)*5@uvG82=eqDo z|7UFv`K#OS^N(o1%fF-jZvX1GhyAD99`&zpf6BkN{RMwz%j5nFtxxzHThH@fbHDH3 z?VaKu=3V07;;r+~_D=Ti^B(bk-|`KAgLjqxoOg%+hWjo5a_^`9h2Hi4UEbIIGrV*C zx7;82$9mWJ*LWBDKlD!bFZO=!AMUO9zw2G@-{{@of6u$l|Bd%E|8(!y{z=|<{1x6g z{`uZ_{a4&u{9CDJP1rQ1t)lZfn(y>qZCzh}wERfwQ^_W-pc)zdnz|q9&Wv(@=)t7l`C2vsN7h& zq4Mj>wJkTc+|;tZ<@oUFmMhz?YI~sN!Ip>wT?9 zwykVCylqw6ingQLZfn1|?cBB-+J4aX)3$YOKWY0;+mG5VZ@aYZvbJ;D&T2ca?ZUS6 z+iq^VrR~18ontJ=nIP?cTQg+wN<7rtRqVHSH&~pVWSG z`^xr9+plVWwry4W@7hmkKd1fN_B-3pYyW=x58Cf)zq|dn?c<(2`yVcB|340AP9_cD z&x*r&Rd=#HMs8$xImO6{y`}wCdx~pCc3kYocX!l}0Hnle$!We%99 z%ON8aPB3fIZc@cHBTgN23tP-dEg-@=sB@#MvJ zKkEc2ola!&%PLtx5c!eEoNgQ$4sG0*pXd9sE4uH@%);oPy{a2IyO-Hogw`Ur(~%aP zmLOiYVi3Z$UHr_k_zwTbo>;*xj_nzYY_#T89gRi@NQ)=*qn-&wjdYAjA(O)XDGnHl zeMb_yZ&CVmQe??fD3VG%iVS-|1Vq{Dv;<;78cTeW9a5OTbzth*8;*p!37`RB-*@?Tr!T5Ql zq6O)WK6gpSBOe%y*S!UdhF2x;NpEQ00<%o$Y(j;=sKOm;PLU@Bm^s}g*4Zp_MNLs5 z9F&?em~`S4h1c4!2CnH|Mox(*5-hy-NT9))$$uhk=f?IY%OnsuQw##^Lb1~a!jZv_ zqkepVbDeONVx4fq8dMNobre3UPTA^3S4vI*B!H2&Lp|H|hmSH#)d4b8mFQ{M=?A@b zXMyzbl|n603@8!C=p-UN1pr3&xgh=h#|;ix@dqQ%2px($QZ8~)OYjTFbzuDxZ8iuw z^tBxNqz!?u79t=pJe(bN321yF<1Cw z!9Y<2FDl0S^oPd^X5Ltd>US+$0TLJWSBpeJQ&c3p7LtlO$wiVFTPM7U6a{iTa=A~G z%L@Yw1zro3&srux2|A)EictY9!F=HFiwMuQAcsdBH)V{L;8>dX$-D|ZK_ev?{!Iz~ zC6wSCm{~}>vZ@d&rH=4rLA4vp3XMQrL_W}bD@Ei-5exy^;T^w}4TG|U2w3xC??5O} zE1-aZkD(Str9ppPdOWx%Tu)BiHlwD4@7OMErS)|rQWI9MdtscDitjox#4x9(tO$olmg&`R`>wbHQ5zK-Cp}(*Z|u9 z0<9XAf6B;vrq0Y7C-qF+c(o0=fZ*Rtl?V7FB_4cp5Iz0oDyAVd{DC~V@fycS##Za< zd@b#1Pf7+d3pJTI7m6Ju30gs%3!OwdLB|z=yGZPfCX}EvvPGdpc!^@n5#As~abPvH z!g$DWX*z3ktziX2bg-FX*eua~VG(cwA?R$zG-}zBfc%%5QY5U*Pu1XK! zk%0`noA8HZQ~vJR6`ooX4dPzsA1qc>+^H&AqlewA7PZb4JK8hd4OO>9*+Tcyz^ks) zI!$+b#JTC|4^6uOi&7^N7~Y_P!+TYM@;VeIbxmNkDQ=YUcIZfV+QPPpx0A3fyvo6~ z;KcZGD?FCHvVuR0=(mCE!?OgpR(KS@gX`=~ji@24IFluyPBR$g9ltO_SSR++)8>?p z5c4o2{u5SXMx+Wu33W^=5e1ZYX-;6S@B*pM7jug0p~MdE4_{vi_+U%nV9>*Wasluc zilGZod4f#jwm#X=qK(Y0|2xZ>DGb}|{3jeED_nIrkreC!?{vs96S%1ej}>3Q)jW8` z`-ji77_=c!b;*_)fP5}h2N?HfC>GvM*(G+xK){iLCLp)d!5~Z|6ts5ub+R=vnT+?R z+0G&GAsiHC%mC!ZSMk5#=h+yDDOC(dhSksk!x!DL;4C{G3*DOW!Jr0;$^?`s_%1<$ z&q9yW$B@Gf={nj`f#Zm3aT?+k;?3~4vH;uC^$JM}v@Q9<2gNd=0K9cnu7-u+vhZfn zSO84<|L{lY(A}DNJf9u$_yR`bHi||%ytq|@g9;o!IVlg&5Lj${I#L zAUFL&s?|LvijqqS{5i*kH5bbuq~$nE2>rFHcW%{=LD0zkLe-aYXtEdG7zp=*4~_J_ z7c11-@$#rJ5qTwBuv2|T6llWx#N9@rqs_@B|J5t1gqkt#0qYAuEU;Jgy9O&Be(Q zS`kdksC{E;(AI@?3`mUxd67HDFrA1gdBZ*!tZ9%)?~(tD>>Vtt@;=LkdG-rU#pZEA z3Dd!0Yg_yHZ78TB`S@xEZ|q>%J6Y5Qa2YH-m9`ls1GARKXEKaK4Ii?doo!u%!wl`2 z4A9%O|H6T6!exfGOa>?(>Jtuy1O|^8S~D5)K>ExOW-{bqC@=%r#&k0eLlZMpG8ytP z6q%u%$-o-^hvUtl9I+S8%uvc?U=1I1i~nqTF^(Bvp@xJZV1{vIL_7A3iyI!)dHuE-qC|nOVcp5w6GQq!VR|2y^v`>(u8*5LsAI` zk(oSg%p;11^bI#i9;j~0hJxl9Ev=o>d(*^H*YVb^rKMmgEx{lo!Oy)C8yh%3ezxv_sG&@V2Ak5gAw zmFj2jTM2^pQAuLsklDgN$e~;@gx18O2p5*1+l331#YhM;#-O#2A!sK%Db_eLO}Pc6 z4Z#w?2qG^LyNzfequVZ=P2qy@o+E%WK`5+mmqMruRt0uo6qzr@n=ls!5ffB8M39Vx z|FrKf@1fS<(n^l-d{$mf4Vy3}Idp>3ePBg+V2nA52NbR*TX)*XrtLSrFleBMu#%1> z?LKOsT0bM+rOt3LBvyLSUJfgM9xHc`1y)qglt^Z=a_(OcE2kF_$*>PeLiXthnmjPN ze+_M}SlaMWif!rdM5thS!^h3#jKO?`DPX&V(J}bXz3&nng&&ls{(Cc=(Pz9bdQ|f^iIADK9 z0`C}C(S7f1qWwd1xO;gVb77^DhtND8K6U^yFUAPmj@u55H{ublXGAP z%c;6D1@V3Z3L^HCEr=0^ORGAZ#d}_QK+`Lb^P?E5M4DSM8aZ33t@w)pup$dd{9&qmnp#uhH3&{vo!I~60;g*Z~t!%DN}<; zgG0kEHj!o!o;6G(i7G~KIHI~KQAb=o{PNAH{?j!KU~A_OjtpxPe};qR8V+<)%A!h>uwT=)}jvHQ(HR@67>M(2% zbj9P%6f|AxDrT9OSV|J%w>Xm-?SYk;=5#3@in4yyWQTqaqQ)7&hu%(cIw+D1B*tTA zi>?9Kke;i|kK)Jh9uNXM$6&hJctDd!;sKpna5ycf!*v_7p5bsl5IWbR`pDiOjO@{x zxeOuk(W&PoxHHpKWCgUp6(`4MFvUJVY-I63#w#kG=Q=i2yx$wGKDQI07R=7TO2Mt` zsXC1G6m(mVNe?w8zNII@`8_%OL*}p(p)e8x6XD^Rbo{p^2I+g2ImrQN@d-fgA|OoP zlN6^*JBZo(L+MVcXT@cihSap;Ozmv;u$b<@s_}Ospg0uu(IM~2X z#oQxdI>54*?zk7Q|M9CY4-QyyQ}_+mjKK(Osq}46z#ti(kqkkSLHWTm;abza*`LVN zaT>#{f*hbA{4SYBp#^gVtd_mMiFu@du#I%{r#K&{M=ok{GQNWUd*SSQNV9 zob0pc>7~&hIaaCPBG`La$OjJ9kf)qNe<;(3p>hPP?RsLMc*hP;$@eIc&|-ftxfz||(l~Smuxbk` z>yjjCRPo5OYauBpn6Y{VP6Xkj6dp#L5$_mt zlN_1hJKl%PG(KFxOw5w#w9B!da=B+*&~d4#a6ubi9ztv`p57Yp2jj@67hD{+QhT?uSuo%F#|Pbrm`;QWSfD? z*dDSj%K9RDMDb}->2zl)o|9VdXRQP^S2Mw^Vw(4}sN5N{^7uRjD4kyob5pkVVPQs* zA^K042RLV(0=<$BYXbEHb)ZgBTZp~7Rf7+JzLRb0Ko^lOy&gn7$~1i=Jxyc#lKew> zXi`>t?I@VYJL(7LLTY58r2GH_VqqWc*PuB0=nOJwadPAPB@sYn>R^`^O?P(#Ca~@@ z!WYa1oLZ(2*wdZ81VyY!%jFEz&Y#fvWW-!mh~}<=+ERJUXs@BiyXtUoi0Cd=E&7#C z@Pmt?#E8yyw)S*_bH;fL);i0JMuKilC8$@py1_sW{K|UC0@59h-|z@#>*V+roF-wl zCR8TNI*q9D+r|I2|4;%0s$0o2)#gn{c1=wMUk~n@WpL*pa0x6Gdu=d3Ic8DS*;VO# zRvbA*nRHkoq?YcQX6pcZ7kW^YRWYEsp~|Kd1|{7=tP5a!4rW|oT>SX##|NPrilG`8 zL6rsZ#gf#VBncOj+E>bpO86Tk6&XoZ$f7D4r^KT(;DoH=Y8g}-A;8FXS3xf5sM)`) zAURWNZ%UfwYM%N7S-3Ii#DA7aBfzEbej9;GLBgW18gP2y8H%IBECU>WN%u`()zH%6 z>}saY+iUBj_5oVMKXAyQo=F*6r)2n`M#lrTcs)^*tPhfwex$K#TH-i8h5nA(mar^? z(8Fh);;ywj%NnUo(Ar=O^k9+cfT5qM77k&i+FS=XXrkIN9Z(!quLFxHh~Uisl#oDz z%#4e zu#oEjB^>OHdWj)G-BDFmbAsnGv=aR|PN~YC{-~s$y85HCdQzHF2~HV0ltvYi1VLVGgI&VW^`y+q|$SSAub`|EOVHLzhliY@p}SlPkH{90;U$NNTuGOE z1#XfhYqhn=Hjwe*>Y7@BLR6q@sd>d{68*u%LyIgmSJFH1_B-#itXPRIVWwiG>=;p# z7SgBSNIQ#SL`^h`i8Ue?oQuVAUjSnZ3b|eB+zQAdP|Io?I|5rUMEt14vXrkTgDgVO ziD86naOoYuEDxUfTX$Iz6Z~iayp_Q&wrv*YkyIu$_BNM~VujuSh=Z=9w*&bt+Oof#nvA&k52rOd32?$WboqWO{yP1$44U2 ziT}td3$pA>p~LM*x3JP(<6(=4%wS!SIV#JW;4g-KQ;|8k?%QES=9p}eT9K)JHLS=S zTT@Go$ke>r43UvO1z)W%FGH64Y+X(iB4hg)BP9lE!_+8`PW-e< zRZ=Xeo(PXT`ck<(7Nl~lprlAWN0Dkm?c$;kVgzGevbX}t7HO9vcKocVUcoM@Zv3)I zt!XI%u#h&|WEurERHN9D$I)!k4^d32AM#kEji>}9RrNz23xY*?Y!XPIBSBI?k1nxx zvOf_<*tO!JdXh&1p&wm=QY)TBN%?6p)sSRR4as9Mt)V&9V&l@vf>eu@1U_i7qJgih zwHWy%7F1pAor&!OX(_M)4<60L@SEbv+Q?#s*U~2tu}mh#((pek z3D;03#C9k0W7Q$o+d3Gfq>(9xqPXl|J4=8E(efBb6a*qxFH3Kc26U=`ekLgO8wZ;% zla>+Tb+ln~7@@Vpb)3Xvi>l4Y1Uk4fqRNHOYKVw0M3eONAhuMbMpmP{`TFx>ED zE&wLn6UsI!W6-%O>#4V^%6b(7#kJGuhD>vAJOfpPC$RIVg5lz1`QlT8KMnvQ3`Q`k zHE<^Lo^?YXm0I6w$E=J)bHOfpPU|l=ngMcm`AHQ`X3dh@q_s~{LNr~K9%;E`) z6Y-P7v)QWPR4-@fJ+w=(>ZJ1rUBFcYZ+Q=5hRB9GkT^GDl1Rps&_<%c3RD=A^yOL| zC-OcGzQ$MNn;giGeZt}EDnF|ML#Ybgh?{M#U|JgY1JAgca(D}`{07bppcD`2m@$B{@PDL~0t?WTP^}Ia7u!_&}EM9I0ELB{>{842?N6)jtwyriz+6YNa0O z%z|k^L|&jJm7IhfWkb+zvO)%Mgx}>J2)O1psL4PCzF0;!eDVip3bbRd1D2RJFab-{ zJ>HCUWqB;X`ncdv$d@IgA{5CO9?G7OXH8i?Z%8KTMuzcI@)$qXNh!rO04c^XlU*O- z$)+cRY>bth@W**X%S14EBUW>2>_cwi%}_8x@hn0;96do?LM(_&!LN)6bX{7V$c7>n zFf&-(ad<37>DUl5n2Zz20E$CL$hW8EvACY@{!qGV2sEPCf}DhBsYt@_=h3M2ny?lI zTeXNvIZrm~)MMFm1*)lq_bf|jDRkSSp(JWF!;^*loNOqC!a16^j<6ziywM5z**E6Jgy zF;zn1J5sOiH4LW#3gD%_217JwRI>N2Ji=bx0tmb8FORUU{_t`_k=OX6#n;+AzFyDZ zi!)3qgFQJ6gY9P+44D!J!?R+rBl7s#uZF<}lYMzZa#)&WXcn74Jc|KitLtG5LB3IO z*mv_7`*FrA;XcI_V>5=bkuyZO&qz@WvLZM0uCt@jR3jg}NCPp3lzXdF;Kv3-btn&w76* zrv0wGzjN{!A3MM0j69~dTEFGIJQ7aHxWFS9Z)I+C5>EShSRNCJkjoGtBjTILbC=Sl z^?YHB=kmUAGNKSEHlu=(N-?x$;=q`)v^ArZ;veMEId(ktlRPH3TAun*9tmTw%FfIq z<2|d&#$+ISK_27xXBM+(Pw0}<#we_Hyyo3R-td8Q0TQPM&q@q`n8)~T##%%2CMau- z%oyM5k-mv3VDQQs>%|n9TpLr^GZ$0vhKwm-e3-@*5MbaAe9jz>EWq%oA&fd!E+Vv* zj)k+jVB;t)`no((-r~48Ia#bWz5th}K2_=uj8Di@!zcsbUtyZVWBw5Qc5-RC+l7?{ zb%)H1&m_3xQb-lR!D1IWT$^}AqZvkHq%$fv=%;z4U7m3_$0i7Nbsl#^=nn088ZVO} zGEE|rq#e%@8!Gyq+R@YzoCa2_K^zQL>l$_@KPuWVN~B+uNBY=Vtz+}ZHjGMk+^Qlt zKg%Ow%py2z@;LY_j^JFf#jyB|_XZY|p@~tO6wc9V!AtX4+!A4(!}AFJ^T)xUz*Z58 zyaF3-Sm*LQzQ*4F8O&qrZ~hMmmpd&R?nOGEb!DC?V{ghY&J*RmY|4LDPZCCJ$_MjE z&uWgfH33dk4Tq+F1brVUEeUrcQ!*C7vm}Qr@@U^D9Sb0WKBHj-J;`CI`K&q-^f^O# z=rUK!u|>GD9=_I&GQ4?B9$#Z-_1|I5YNpkh$vJ_)Vyk~`9*bLo>(1ILxbE!Xxo)TI z)Mw2C5iB#%%Fzk0BfeyWW_BG#Ztw#R50izcSmI%;krT%1YIMk1brZVA@rn+{yHRAz zYbB$K+tAK031rp5!PK&QTF+ux7);AyisGa6a>*o@HL5jrT-Rw_7Ocy}95PS4))1(5 zo>=$uwu@DsI0*<#Fu>(V?gY@Nb2CeGlEc`S~-9la!v&iAq%{Y5V`w}2zZ=@o3+mwu zdm2WCubcDu8Z%M<6Kno&Vn=VyV{z;PF~{Y3Ez-QU)dga1&m&>XSZQq@2YC$Ku#WVy?}j z^S^Nr#208@4ZGR^IDt!HgbH7Qu{W;?@Y@2#5N=&!c4QJlAgyffAX~-m0b$AKh|DIQ>0? zgvawp7&AZWqC5_^PCsf)f<8~?u{g%-^1hSD_N+E*;ps zB9HT~8k}Pd6nz<7Y)W4S9#YnwF@6jeOC?LuWKmkG0uqmA>M+sGJa2-?qY7zm%%f?{ z4B5}~==m!)WH08im<^Xn3QEHpO zf^bDemEtkk`jN|hf;7`TY%}TvK`Y*Ih!(#tb-Zhi{a*fjkE6E`$9|s;=>tB@c@(vK z@V3C#207z@XpVi+P8qBw<_b{k@R`+sSgjgh&@?pT4_S;xm5+j2N2PR^ehpE#$HUSp@~zB)4_9K@v5pw>_MzP=#khu3VPa`FXVl!AiK zhvY0KvY)=~A_wDhX^-k?&wRxz>mlXYdfog^y_~D-C9aZ0!6{DaH1wZ5gbH0zuZkn< zCH|=%SOfKPzEm&gG4*o3BRNOJs3+Ac|MtksA6~Eg8&Y0yH3Dj_tyjen^%9S-mv~CO z#N#AUVIa?1H7em7^-6CP_*d}g)nr5Drbn-eU{qYo=GoR3u8R$?qk+SnKTgn#FZ}OP zd~kYd)x-4iUR9jo3AaJ+I>S-UyqiHb+R2%$s}CC-u)<%n201j;QOjI$m={h(l%=h` zP+=1}(~K7E`YlNPa{0q%)UT?hV-uN`wNCJv^n{xf1IQv*n8C{M3bTAC)WvZ)_##sg z`_yZ%48F%;UUK>pgL&zJW4PUGJWe-*!Q%BUu!U9(+5sz%^Gr24a~Bag9{3IewNl2XL^ANjU!$P9Ns`0WiKQKr25WdbrWNH<;3VNfK!)qDD3f^KOh1mSGS!z2`+;J zYDnTJ*OkshWcM!rytoDC{*Q*&f2iXTiEG~BfaCt;bS^zZYuF%ot%hhRA1DuoJf6i8 zakM^>1OZHB081?J7vie<$iXqG6cKtCi9qnS_zW+-b|^@v1Ol0DF1*kSy_Eorpkgfv zqpA2^vA+U&IQC!B?DC+*^A6LTa)tgpjSNOnPA)#LDIa-N;9md^wE zK9{cSNq^9eeaa3Wpm)z^zRm)UMOQ_21%7Y1`rK+0FD$DT;wsPhEW|r}0;}%}@qIY* zlRB#qKQ4!V7I3=dC(6F0sN+Bj@taJ+C6#;j%N_0GcE@R^IO4ZX!@Q?7{4t?G=k6Q; zIb%2cot|6%sJWHR2l!S7Njx}g<~LXIi6f?fevqzYH+Q3QPOe9^A1*XXOSo8 z7U)&0tKJH@%Lnu-WH7A=78NRvW#gtZyR(@Y!0J%fL?LmAcqhJBfbNQ) z6!G|@I@i$<7~p`oy4(ZEPul)Tm!AsS@{D|`7o`4Vxk&j_Ki|Yp-bbX7V`H?DbRC)q zC~0NaZQu}R+M+K=X)@V)laWmY94di^{!n++X4w$8(i&vp(g32*2E9~GmVyHOSiiG( zXFCf#x+w2uAjble8nM6;{8}hrPGW)+S$Uzr@1_LeVm*j)9W1KB9jq(xxtbR*m=5Dx z^CLu|wrPrwX`F4=Yn*(NsrpH|LqemTy%WsfjO#jZsBMcD)s*2$A$OSxkY{jd}B z5fy?G<BZfUCgk_xUs0~W zfIKo*4p67q+(G>4(}u&_)eiz_Vnogpg00Jg2|#U zg3C*cB`yXZgTW`t8HOrWaVMZi8AjgAu|JYG?9oY4=LhSXyLPf{wB+Eb1ymQ@f#cs{ zbnHz@3}$m!GpK;0=?$6_oOtI}eNx0mZ*hujmMS=J)@U*zT1tG}?xBe93Gt)F!XJ-` z^0II`Iyg8(7G`XS$FN1N)5SaV7^)F^ zZD3##uSQrIJW7N*DVL;M{8*iCNBJJEZYOeuWW0-y9ihtYwRj&+Jx4_4Vm(rqD{hD< z%&~(~9?DhFH$hn8PuVB(wuHwxoS>TuMW)ZvvFUX)Jf@oWGI|C`L{2OYP#)ROMfN>f ze_gwss~vR>RXfUrH;MMsy(RV{_gs*j^&v8*E+gbko#&~B4nqI~aZL0*DMO+danW)>&f_EC zay5x0exFcBjVmxlmkp$#(siyF#YDMe7M(bTfo<(^h%l&Y+Y(3Ip(7qeHdJtA9B~^) zSC8lAciqLo6Avkd<9|JAR!=Ah z56-Mq<4i3SND`4cgSw{d3xKQl;-rBfonR^L+}7#PR=4DWj62*!zx-t zdlq6CG+!yyayYA8!&?7Mt88)KYHCpYuVDE5Sma;XjaGC&PMcbbJwx<>oFN!>k;j80fJUGO-XhB_LCZ3llH~pJx$>1DA zficHA`-QpW4P%e>4*-wCuNsTtHN=sGKk1GsJZ!NJ{eJ8_beNsSPg6Ehoh*Wi@iE5? z4qzNCoD!dRJbzqtIzGd%^OkDH`oTg~H(nlIL^<6Sze~8AMFwuf6e30a=9R6`MQ%&! zZv|^IFw`Dn3*o2{xri;vdC($vAup&S3*(~;=!Xjs9;T&}#u=^i19z_}kq2bSfzp7X z_A>hHLiH`hk&lf%0oU5;)OxD21i?^~PWbQ&P=#0+-)V!acrf$p)HJ{kvQD55*vTph zF5@RxfxNK~1@JPZTGSSi96u{Bnn7V0s?0k<^A1)ie2i^z(Cs98Dze938njY0jxY88ma)}Z}c%Ezf95{?80z9*;` zoNJN3Ua#!PXp$|!YP!2(-p01OoOg}SJ8Tf5h7~X*aL|e*7-*2(Q5s7Yb;Uog$@G2; zd_@aw#h28)2!?(mZT+GqwnqXdzc5sT@UUV!OYJ z8Ax8Xgb7wC6F4yOx)towcJXQa4s}F6f(DY23a9U^U<57Eg_539x;DS1tKrZ|R7g5z zVVDRbeeVFU&FC$K&Etqn?!xT#K8wLOdWY_W-xSqXHxK5saba68okF=T$qru@O@s)a zu8`BzxLmW>{>rvE|@1f=u16wfqGFlqQqZ_>u0 zMNH#()YZC7VxUIdXNu}s^>L0}Fk#T1)Q6OjtsVZ3XcD|Z#Z4f`@iH=cg5c5tbs3q8 z$HmK`ns^HY83$8F{kUw*kG$O{!dreTvB&fieB{7&V5rdRY~mO4YeP)!hYlgk4|>qt zAbY`##xXYm>m*Eum$^2CYy;(>V}V4TLfcf1Nxn>IyarL0gzaN-6?9 z91xH-Deo8>AW&YKPhlpE7<2uaT!j*K`r{oKzLx3FpQJy-0)i5k2-2uG8w27k%>Z&^ z9*{F?!XtS{6q5E^B@klZW19w?gvQ4N@&yR^jzCY&s!Kqy%V2V!jG}2cpxm=`lVnQ} zuNM{C8ehJ0Fjb+~Wrn7ZRYMW3+5l*4hy{^VNChtcrqH1RQ>RI!4iH%GH{Wc zm^u+UP*lSwOos8)5^xgLRfj@ZzJI~IFRAxMx_R8t$d`|(dDrkU^$j+WK`guIA1Hi~ z%Glj5E=NpG&Z|A0i$Ych%L-LMHLx6BFMtTW!Drw(j=7b1rpV=Fl)sd|5<`5QzB>~S z*zYJg!`rfoZIPP2;@I24V1sH$7J zPnTa)iW6+>db^ppuFm z!AjnZZa8%Cf((bIiYX_^hmps{=ntt;-i;vtGB3ytRp4z(=!TNh$*2$jr~QFzpH;Mn zH|`HgY_^8{dA>gfr9pRMuPRBxOr!E4ic@v=xO_$6P{{)9F-r zNln%TnekA@LD;nEn$C(;;`#znO``_HLGu(sF(r&+(UeRE6DOu55{|}H!Zm`ai~&C* z6G_ORO7%Lti`glM2ni_ttq_71#C1s!2(KhcW7d8qET9mU{v)Z#W~r4B3Dj zWn;&3Xv9$=Y!Qa;-howQ$uz3NV|v__g1`|p8sDVhU#T@2$soOUxY{FQLfLhTambG9 zetYHl^r)FD3`#KhD~?nT_qSC&v22{@k-}%1agF4+k&K{=Y==Yk@d)J5p#+8{U3Si` zw-B!}hBfl!JuNRQ1O{{iG{VxrDU_rdkgRwz#eSD```uLN3Ed9&XGW%a!ioWj#kCD6 zA(p`yW{meZ!s6Nr@g4a?b`5gY0-4c`#FLZoog^hUn+X@NWCRp~g=CF1>Tq@pPt~$7 zHRwH0Y+OC6O@*$?#nB{ilPzWP=~12LpW1Wevq2$@gnyDqBLiicZVGyE68I=wV@Qmt zTZK!VP4}#10#?%b^tLd4SPNYl1-BQT%ibk$>)!-6;q`6d_N#EB;9j$;jgVk4kP*hr zH~}E4xE&f&yarMoPQeKum4LnjlIsv3_o$3VbFZmADzbb>+-!JaNbb^>0W(i#j|v${ zp)s<8cF+vqoyK06-8J>n7-JXTG_t}=Ww+Ckq2|#gh{HjahZv>A#3km&MW6usKxh^2 zSO#S#hG#0)P-;fPln6>F6@(E?c!k!&2`aNt{6e7E8}T;w0FEs`u&@;|p18Ds)yoVd zBbr-=(@?o<4ji|okaB?dKJtJntbz@{O`wAQbnpoFvNggWJfsZr%Lki7W2m|lGKpvj zwm4G05JCYPC%lf?Cr4Htb0R9dMmo*$r)K6ksWQwub>Vj;Bjtf3P{?NZU4<_c1v`uT zt;H8eqrhYJ7INZsc!tiIIFGyKqNqua;QGJy0B>Ay5T`iYkzynu={C(EhI! zF@QFWr(rnlg{y@Ipg|J)8>z1jgTlO;x;2VeU_&VFKI+SJTDkVYkkH?kfv;Rr#^H;YDUtpu{d@ZKaj;m5M6aJ{rI2V&6T z0rARWp;;_u)FBv5rn>QfW88teT$f>2ad(#A=x=HtKo6i^C0Wu+p%;YMV{IHf*6vy#KHt z{wVfRaC;7mqnuiZj(QW2W%<9A!X#UBU}jMY*;GGJQh@99>1fMJ_~BrXJsDVvB{fKY z&Ta8Fz(QM~1a>`w-lpvTu+@K>|!sB*xGhCrxei(bT-0IA_0`5pWn;pZM{ z@-vfHNpf&|&HQZEXR9M(YLRYU#4@4%l*uXG!pN!_* zWan5fqNAofzmYvJCn6=-bb_od{%VECTdz4#6xm_ zW+Nknk>rXTa6VVU;vYwDisjF95dKc+%~_M-Y=xSu%ri3h3G>>TxMC_0uMkUdyJ%`? z_efg`8V1>|%W+F5LSa10wE)Z_&x9&W2_{}Bz|{JX;X6$E37p}_OP)f2g%c2U+%e8k ze1Rh&7pd&d1Y=Al4<{VrbBi24D99pq5$!csmAog)M#u$CNB3jFr!F~43Of!At$pIA%mvTkTClW@fc5_N$xVln4M z_Gf6;ME~4E9u9)DoYc#u^QgH)=nXCPTaih)Fr2tXLDVy`3Rf$F&<;d0FRENhC$lL< zqA0TJ#e{#MCmeAp?eH#DW8zOb^e5enhX9Odf6@_uvgVzjjL8{)55tl6e&-rwAQ)ZP9uW#eO9jUktSU-620-7<*HmLQ^nMSS{Ms6M6KzD z-{(0>BJjYKWtdQ=y0Xq$jL^1@!z#}#w)H-CW#5w(w(HLvM7%3mVXO8B0bIXRMOCZL&P z`tUo$j3(yt%lo|Xujin%?r*a=H5Lh?+Oq;$ZPK1 zqe(d&Ir@9*hjf?Xlk$$c6ni##_kz5u;N33$;Ul%>-jR2hDTHq64}N z^yM)aW`u+aKG=;qo^GKNUd;pnO`a zhT!F@+KxDUaKMVE$Cs?acladRQpK>i=y{nSm3+FYpUPZxGgtA)*Rw<%giobq6fm+n zMh}3bpFPvveIgA$Dneo1L;h5ch?Tp5$4UDKG0*B%k9*zZz{v?X2|dz z3Vw(Ota?ryACz|x)$Fcd^e%o>UeJJIJAOt^8;DeY3Ou|~U-bzTXP`uno5(z}+*88a zT#ukpm@dwO0ALxIo*KdkgFBJ>gx1)UV_~upR_!heh$`Y`lI&utibKY_296UpFs^`)5Y1nf{}Z*gJ65AXmM%inE)u z4Agcmb(TR!i}Vh)@*@1LnrmZx5fcK#thpF(#jmZu266y&Lw+76D+fE(P}^42h7vT( zM!1$k>I@$i3Cqms-Q!_cn;c5qllZUBO#Tykw#t+^CJRYCH-?6?;0da$Q~*v=(>-6rUL1DS2NMq%);gUf^kRD;8f3SgaH-^9pJ%&`@(yd>8ZoJ_B~5;6kP1%(Xk zNmovmys9fq!P$w+(H)9NmvfBWiZ0alCp?t|susf2`2963!!LXR6C?=HZ#ezBE1o;# zU@X3G+8YPrtveD>#GUck(t-|2gh!EF@p(t^-E|62@o5ylcyKj7jR>Mw(B3#!BHtAR z+H_ZnRhWS;Jb)jF7 z+BoPSS7ioI5pme#`VRh@5a5Z=kn=G(27;hoBFe={dZso_nd2{jY6%^JBwV9Kj3mRg z?JV*u>br>i5dS^+|0r|7M!>Vf(U+>~Jq|k5HS+9A8#!Ml^QqbFGaqB|lAhq!?_X{3 z{`K_z+b^^H)Y|fIrtj<4|EC7;-)ZpvP!MQ1_^*}nx-%;qWM0+a{ptqqk81G#mo@c!Ek-hZdT`?DIn|7Dgl z&S{YOyaw-o(BS=#8oa-t!TWU$-v6}0`->X9|5=0gmo#{P=`iofId5k<=Zax6lXI?0 z-ybVFDXi5gSEujm>XctLc>k*g?|(cz;^nG2(9%=CY zu?Fv-Xz>222JfG4@c!8b@1Gy){r^f`TsWyZyk2vj#%g_@hQvi891u^BD*Pc`0GN0O z&PDh(z3lJ>wt)oWzXZFbb;D7yC&Sknu#__aN5eQ6aC4p!Cv7?s;i+6Ne%QvN22($5 zOn|(a{IDsIwMzoEHwBN|2`^$784pliV1({+xk306`x$ByVI6IpQQQddx{)EUV!n z6?OQL3s^XD$PX`kn;v;5Im1vGCvEKlx)TfGI`$6Z9qb{ICmUsVdNj7!y|ET~BfM zuBRTxc^j`|#=*E?iy%H@%gXruu`z<#41#0=4M)nBXv5P0Kacr@D=xD^uzC)fyJBkc(w2&~5QE-z9#xP0)+hLNv;r>YXTTNVa+r0^Rp~ z2uoZ58CNp8uAwA$r-0UsrQj_qRggzXndc#Lwx z<5@{SrNduRd)*&TGoN`=^Wzz*VG`QrAXuX21awulfI47SuGm7*-*g8te$^cY`8XS3 zUYLF&)zBy(FU?d>Oj(t~R;{hfK)qmSVwxr7pP#d`I@EB%8FKvA! zuFSryVNZbX6QrZu2f+eG9AMLFOVLg==gy39GXl-fK0J%X3RkF7=l~AIhy4m_O{}d5 zA2I8jv|0c|LKh?3jiJ`yg1qtjWUZ8HE=W6=^z^;*P$dS4S4A@#TyPUVyzq9xd@xP@ zq|H5F-c~KFC^`R-bNdl;iD7u>9Z^09U>vH@OgCSS(-Rqq)oG7l z6glR&nzRfETG94^rCP2Uqfh1L2ngo%W2_&Nn^u)GAx9#|rR2C{cq*i?bSta&ojpnJu-mV;FXSY4q%l zu69dL!%M_!P+8SV?(dE>l6yCwf()TWyJWN|rX*EY1sO__WO*cc7JZe`MYxhu-3(a; zdchh-1M^W)JcM0Sq!o<3q7WUv%5SC3BjAt#f<91qN63rq$sAeAb?Ho^ZvnuwlI=ra zY_6+d$5VB4$#SJ{MBk!TMN}#r^kXIrwSdYG#9C{)8TzIOHpUlCwe(1xOXQ=o{3wRc3-VI6E$3?U zb!|U*TsHW5C3B-L9FyHhZNEPHUTmVarMV#4Qel}b70(IK$p}R{@{*)&YTFb~>N?Ob z5q{Xb4XTcV9A2g)+QErkc>Zv5-56dOXI7~zKWZ@nJJbVbCOlAkapb54uyEG;`#)mQ zEp?ZkzlwJ`x_EXL>#Q~TK3tm*qq^V=V4gaIDaC1-6Jw#dspa1h)H@j5?PRq?;K8_s z%Zp618Ak=DIkInwijP&zz$*S}&J1=?I*FuRc#@Inq8&p&MlJ?RFdX=Q_le=3*ixs@ z@)!n0^ab6e@r(n`U$v5pAA6V$7v+Erx^VK8%)v$e;c5XgX84}sL_A)?L*7Nzf$h+! z2swC>7SLvJ4TI(_wkPR9jc(lRL%VN8Hc9Zd&duZX~b_S7K;r~w*z1p)-yTlf=nL30VLw zNDfy}Q1O^}+hbb$YWnKg+CN|c)uc17N2Ik0Iy#6?R zrqf^4f;M24W#Hr#cuwLWeEygDb~80EQPYCp(g(u&%t=qw=p}=rh^D{jK#ML zpXX?oLtrM))9XfXttD6@*imxF1#U3Hmh$+mS7~*V5-}FTBqiXJ%cWTW;D)@nPJ znHikWL_;k7vT>5Jc0h3TLHx!O=tTSvCa}4el!T)ttJC6Z*YoZ6@OhGDF?yYu1&^3p zz~Fvq2MwJtu~42PMDI{JY{5sQQZHF)0K$8);Jgif(=S60TSj9d&vYMj)w>7+s->cyW6Y6g&c)Io+tuN$p1O$QSq0kRy`Ehf#$ zjKHs)9<}Drlc~&HKEMD;=D3cdK{V6Tk4@@O zH8CV25pY?ehFL+|UmlNBTS$?0&CM2dlq17?r28@|lk^3s)sGM6h}QoPhN|TTUkoQv zWfe264-WS*&}Ot0 z14_E|=?x^$oCwqyhE5jw)ubv!Yjk@+^uJTxp+aB>bpfbDxaH7Q-N9~t9L6X;@D*q| zs4xabPyBcsJK?Y_*zrGjBRo-obK`1z%@)+P#mt33naZW85s!nitvYe=8Qd_6+G;ES z_}VO5tm)6YPX*w>|Bu3NVA#d@UJ_xcJ*i*xNTT!z9|ywU*8}0?g!z5vAB1o{ykuW;W76sRfWG3(4l{saHnPFCsFql=Tp;h{HNv7nH+RUFBeU7cEgiw zqp-n(H34%SRHs=ruGlE)_rp!-_r010)@!jOAaOc@{pWaeq40b{Nic%g97IiSO%5lL zZjnQhUcpPn9!~ZOPnaB@jIIOq4gz9259Jm$VmWt?#1DJi=KON;*~&}nl}Y`e2GeOIe}PY6_J$LY$slu@Yz47dLlK>APU3a z`d}_Dz47!#e1uVleTFQlJhq7BVFYf|k|)}@NF>?Po;K^ubY@ci5vQUu!%PnD1$~RQ z0JG-zFu;Yi2r>LMTFlW-x(4rqujZfwWToP_M*Ns4ngosY%jk0MT^Q)A{q=#1-lPilIQ-Qz8m3Zyt#VN2 zL@nynq_+$ei$g3dzS+GE1{}~Uy9Y&U$Xa@ZNpEnTj-l6+L-%Ho>*%=cFr*_&s=c3a zdv<4v)e6v6ufkZ>k?B;^FEaqGfEp^+0@kah4M7WLmz~psB5=v=88FN+QOEaUXB+0d*ZYAZ| zRhZ3|DVwGSr3^fHarl4$kdx{#UU}>w*!e^eSWp{$!4HiqI)_G2V%MeGXNqy3TxN;{ zjx^&oSzs`)Dr*)a3yU=pA8_rFtUNg%Bsj{(xh8@{b!QgF5$K@3$3$#r!6dIwZ7tVn z^kb14H8&h^I5s?G%AE=1`U=G$L=*EjaaIYoRMwTrY2rMnpe6w>uT;$Sfys;v4&N#^ zI-TGSif$16G=cb1QN=051%W_8T#O3+ScE7LbJa}0nkoXsO$o%!%->9iAvuJ&z?gx^ zNP*HK>!mQ3z%niNqG2YK$HE)zeo~kKtUzq@2zqv_>e)H$*(P(B?o4t_?Zta)y$&hk zvWp(hYJ-4ddW{#VKm{jv?WuF3MKtt=(3E{JM0KDFKvQ@>f+z?jPE(;aQAgbKM0|S3 zlrmS&Q7Lj&(dl-2LttuR2`BSo852jYB81>ufXEppYGc(5?t|MDW(@w43thr1hz=#r zhSj+!fz0PKz=REE04llNg{g9g8e#hY6b6V)r0|1hSZ9w`TCXsjKi60*7Tp1CG`@=Y zh==-@wrM}*Iy=1(uP2$I1gaQ%3Xf+Uf(9-M+?uanYlsegyZO69$FW;0IyO0(?SCdb zlt0Vzm%v68B6F zAg8=Tqnq%aVe!p^?@k3@0~xzb<@$7{7e-3~8CYDA+|CH$(sJ$6s4y_XC9!Z4)Bt1T zn7cu>ISp;53N&>(#JYy7WL2n^$c0<`rAHdBu*{ykdtARqR6BX{t8@rEONXIN+j}WsFwAM0H|IxgKP~ zZ;&BCQ)iK`6@vQQ>w_|Cc+ zveL)L146Z>248%URDY7~5+_(ZC7ni}=ybT~yNpxyQ!VgdS@ge&3!4$d?XMQm zTXY*?=zg5qQ8cQx7~u#Hc3-($h`}cQq#fR^yN?^**nI$meyFKaJNy~DAH3T>>$R=# zsXlL&gxDeyvu+DZ%zqzDUbuxZxvbuxM=1)<+i^spG$Zf4g5oHJcPNNBqVS>W9!gam zg3uqVN_~BvnaYt7$c_@mMv&a`f}yx}^F~>Q3|@erf%uZo!bYO9}*f zF^F;q2x>L(R<97Zh#dZO3vz{0R$t#~uQ!Nd4jBFfWQY49aqKSF z8e_-;2MJ-VpR3kb(A>|8oLtQ$izrdZ#em{!$%SOA(^h7lMjw}uVgA}nLeRm#*LXQK zV}9gTx1BpP8LBWri-crcHNYy(t>(MdA806T<)DjCYBXW!U(^86RPnQ_NwErlP% z=Kwh(9`chj6zuzP+~%jIocZ$v^%FsxvK9V;kzf=;SPGeycSGkaxT@JLz|~6b*WgiX z={N{kKBbzBw_)trjR&!*6%jO?jvT66bU~kK&fY*jR!n1#anH!@#oWjoWQ95$P#e-~tuq2xbr2RpQ8&icA9O;N zBuRV+;T>$8U4(rv#35=%qz7R&_=JuLdn0bg5Hd>^i1UKVix4Fize@-Xm7_I=9#Pgo zl(isUCDspAo9I_J(OE`pPwEgW8UlAL$9FihE(-cTO&6cDR!umBZw|{MW6-}x znH$MfQB1*boK(!$fSVbRgy|s3cnAR{YMuhCRt`9WjD=YjU$=28bjo*#I-ux%>L8+uPf;FYv#ZC+S0%`qB z*>)(95agyvw)TU=YFhPGA=P-)B#Mj?=jBv5YXoSsI8lxURt6(DCSyl17B#vHN*UTt z02Xi1Y`mtYCNT5PJh)sc9iTxuu`B2!h#&rpD3z5{YR#cpycXYo{$OT4B-PD;@g1Dt zu=mh<-U>xl(3D^dsN-~$P2_|Lwdg?-&BpZOtxY}%PIa(^%KQRuQ3~l*C@TzqMbK=> ze-$5U^(TP6$R2I-JEu)T5}T0DyuwjQ?>cq{u__M6HNW zL)1JG6+t2L!RSxn6?nc-ta9q1C{Z*61hW}PGruUUZ~*wJE4EF=3S4vs8DL(Pu+QR3 zL)FO^H!uVjm$62A$zMIdEc(2{)*G!hiQ_plQI)VQng-)m;q9w-sf2i)o#0U&8_Jq7 zlSBWU%0aNF8QFFP!Kki4g2|#aK*1eORniLa3}tzsTEJ6uO5kk3(xN?$H<@XInbPxD zDSd;pGwhpA(}NVSQs&SOhcZkrLuN(7E4V!;#u5-AJJMx#7d_%KBiIWxi-|$>z$}%4 zec+CESbha1+oQ8YL15Ke)8qW->(5_)jfC_?XgY4Lm7(WS-RUGcm`I>jk?I)vakJ zW|OIh;rns)*4ht0f4NO8+#sWParBhVmW{rh-~}*7tleTPRbQ(7S1vNAmo38qT)rd| zc?=jftO47E>s2uVAat;R*GOz;4M{h=zhE~S05JkYBsCQ3c4IU()TieNYDkFTzH1oj z6JrE0BzUObi)ZcBA;64pc9aV{CNo&{t7uDv`LVheV+JvDSW@A{SP2nxi{(+`m|=4~ z<4pKsoXMjTX@_s9SF{lXr!RL_Lx# zJZlAXp|T!obBDgyk0Qx&I7iGq#!ie?cV#M^{oJ&>axeqh9Cde<&ele_lTkU z`^x6_SKY6)Rd#pH(A|A|bGy40tL9^e?ylU1{Z}TuCl1|RIS*%Zy1O+C?~z0ISFT+D z|Ji%@Ajz)!&NJ`Ltg5WatnS;Q!EMmS-YP3Ls$)b<&jwca%0#%c1{rzGYzQy2tC)36 z=nu!PqVaA3COrCsMFncf-GGgZ!EW1tWh_t|1lC}{jg6TGEgLYhc~~CvXd7Y6 zfQ<|o?dSXZopbKJnK$dvYE_q@XjGYbALsFVzs@-qGT-jSx2qo1u7hcr!X3?%!R3e$ zHIWt9wZ$Uc;+3j4$&cb)^-rbkx92`Pf>}@R{9L}=Rjqb+58Llp#DgHm zYYFn15le(yHSlcM19*ty{d6eyr~T1>qTw2M&dHs;!DF9$@a!4}?(K?_S%GW!lCvGOPFq!Yi_n!fl@%}3 zARvY`3`SHRhBvKYq^4ID<)R6mtigWbg0KVBX^u9kx4HPB4VRTxaZp@iuufJ0)$6R? zVbMtM=tlRW$tJh2!zL$KQ`Iegrp_iT^$Tpm%@#I!Emtd8PiK?0#7fDh+8mqMc3Q#H zI>=EP#odujz)}dr-P>T3+Z$|hVm&rFQD>8r#wOp>WRq9r-l0yn4#B+d8RrzbXmZM{ z#0G&=PVn8Me%%w!DJR4!rz%e2^~5P^Y8_5tyy6tSu@0wj8_DoNTfYg3`Xr4##yRD+ zboaFy_3KUNiTYJmwuP(D2n@kb@+~%y(KC*b{+wVGAH#<<24|E6YH?TOS8rLPh%Gnx zBmqD2NxD$+2~DJzVF}iE+Tf}&ZNMkDPvMh$*5Q*=#wV|?^9f501D|lSg-`C}D#RO3 zKbp=bY4-w#tw6%2)yZEp)XD3!;x{6n+>`j^T%UcYvzN}q>fW==aa^IC*Q{Jfc`Q9| zsFo;rc|=P(PC!<`8&L;JQ44{}AisOehDZ{U8?4Y|Z97jx0Fw{Uj6FbZH9YX^S^`_i zSeR!d*b>CICt$gdNAT+=HSZ1s(eV7KA^B2!&X%B^rl0jvLXR3EzuTp~Q*)VW$uS}_yz~!T}j2COd07N$Riim$&yDC3BwJ8#ov4!*A z!uY%At9Sn(Dx;d#A883U?8(b9-N8>=rpu>Os8zo*eqA=Lr^}53cje7S_cYp&Bs+o1 zzDe*s*geHpjt|z?d#u{rtPPv`iUy$hucS%auH`I_tzWcdf;NUq;&g2I9PX?D+_zw8 z4{4fVF{@>v&Ki8Mo>qNZIY0;gg02ipongOHwZ;exhJM3VtTwRpof)QuyR5rS-+`Wg zACe`~*)ss3xcj`^dnCUk?9prs5SjSPzSfVJzev932Jb{|g7heK3 ztq_>jvDDw$BuP#;Oz*K2-Ds^(#w)CLkrZS1BcVxUNx4arQk2Eo?VppdS?<<$?C7pO zn%%P6`%zUS2w197lKCuI$cHh1JViQK1;w3`blzZCT%A`*y4Q5G?n~7xZ=Z*js8F&_ z^IE65cdDb>s1TCTx}2}Bz4VrlAk-3W-n-i*8po_vzkD{{I#0Yw5^K4oWlhIMAZpHv zKbN81{+v#9W~5quQv8wxO#5Rh0phW<*4#SJ^#-eK;DJ&l4J~m%tLG#ymV0UXRE)*x z^L1?cvb@JGL8#-Gpvmz|pl|FF7t{}1kq#~r_5A$fPd$GnI!`N*siX+%(ov4&S^Ls*+k8 z{r#~m-p_#@+8`E<^x z#G<4W8hOv`Opnk*$DAlOd#LRZJWkc@niNHJ#VWHERr57awTUfd`~u6Mm`MvxvW$lh zh=42_FD)is(wgOblxyL7#ut{2$K~_d+Ja%2#COLZ{??vO`Dl=ylKL?oU9cMq>4s#k zaekBG#B9_o*FskJkC&BR;UTM%4;0?zrAlJ>b2(?LT5RTb6dqAAjn1V|6p242aVop{ zMJqk)a{lrtlqa(EnuyhEewcc@?&#Dno>l0E`a3Vj>0YaE(jn}@%$Jp8#UH3jWr-eS zss%yO8LTyPAjxBhyAaSQML58MX)g+_kUe4NhclWV|Y)Ggj@jdmBiBTS0o zPLYe2WOt28v`H@}lUbfbN6i4W7PV=BT2y;br?qDT60?d!qT40g z7Wx+_WW`^+T!3T(r6W*YWkH>0m6Tn@x-xoP;ndYPR~R(Mhe~3{p+IXs zOHXLmF9P3j=d@GyTG$_Bbk8j`GP-=!xLP7*Of)1uAN+IIsGu9e6HhQI_|*1M!CzWe zMg}T-_O8H}L7EJS3AO*p?L)ntj`lcn{kiSr`Y$ycp|QY9wDSlI20O32y7qFjOkaMc zYhgN!rZ@gHMicg7X7(M{5I^ihHB6V@i#Q);TG_wv(lYLEPzzg&&IEr{< zUmxKuc#v))Yr9QBS6-o6&KR)|Yajlxmw1i)o4_}%AIyh-#zrYqoMXkla@+Tg&aY_@>TrCL+@=Df z%a{}ywi%~Pjg!&fA()v{^)8RUR(@Cv3W~+8JzjR+zFOXPeDFHP8{I2}ZdQ*Pl#0|Xvo4zUG#q`v zgj#Y$I_IN`l=vDFt_+u9JQeD9SUZZdNDO7Djub?D)i0gJgg7OErFm34*x07=(HZ=f zqAPI=#S0(Sdw1rr?teUo^`F5Z$jM!}2x%7e(juR-D@m$4wvyOX2ddOwAIrH`^AZlz zstVhw8)RYIEb$;KO69l*7yb2yyWqG7u|agrRznQF+xoq5s{B9${rz>A<$arCmb>d{ z`S;bb!%ESh6c(=T5QcSaN$~AHd*`%8bd~)J7K<%c$y4xc@B!_yoAyN3MhCU{ZgG#e z*yt?TSI`t$e)e`4J;j$NTKv=&qdkS>ykwA+E8`HwL1hO!ox>eSs3Zh$nc&g9U;AEe zACXb;U%VHY1xJD{px~3~{Uf0$L8tqv5yECim)UoBg(>NQgWUtJ7>Sf??~0@)ZExNV z6OH@zYMeGYb{i;87+kUnF0$lo;C_yz1@~d7_6IdZj#hW+Ie42#FYDph0K*!G7H{=n zX;KdL&?QJ==K~rg9{aYokuh$y1?+pP#fiIO)N*ts?9Rp6(Z6VaS_L(G7V={O)&>o# zQlV1zBSRgAg0(1!J*hIvI&^X;Y?CKDunfanyZ* z2q6tEnMeO7t;j^17H5qp%()<6{*Z=li#G$aiYPbW(BIk?4t>{m1Bb4cT&Q!XXH2q+ z6@;e8!lCUAZp5Kx6B>txfj?FbZ6C(gIdp0}fkQvGO&r=jjxBQN1D2YJ9QwId4t+~r z?Sob&EwFs|t1NPv)dng9!4k8hF_1qZ9d2K4w{Z{aJRBCLqUnh1O5X4defsncQgX-- zh^^#AHRv?K9xm+LdmdV*XeX2=~=cKA>+u8%e$y-8X=hV+Z7*omNh9l zp@*k;hQ;UQ)Z#-(lA`#`_NOl;XleRN-Zx>nBLDNsW5pS@War%}Y!cLI(3<<>Z%MxB zBbS-2M(5!#3#3Ts9>kmbCI?+9ui{H~16Wm-XQiS_Qv033_o0D!@{1&H>7D(Jq_(*- zy1}+!c^W!iyRj!-jFZ!KHC>u}!^7xEjEv&%)ES5%{~vPcsvV3wpD;A83OM{37UyiX z9qG5?VS5n_6o06z;T-lbWm~|JiflTA`?88O8rB-X%!>DhJb9o9;6Bv$y>z>rJ-_%J zHE(3FgeGQ0+=$fS6tUFn>N;k;nPLp-cWp?9MaHU3q~`kf23S?!W;m1YvuD`IM7z_F zq9i9w<{;wC!ddZ0U3G!Le~0oKfjC}$&&$sWiN!-|T4Spt@*k|fbrETYVQYIBIl&Cd zUcu)a{7{wZukn)T7m$HGP-KO8*ahHAe|kQM8m-aHAJza55k#X_ICi&ol!+q&w8J?9 zm^r!aG4o zjag=cu&CV|ml9)i@!`h`?AgZ%?4uBJ0`}Pi?6aM%L;Lo8J!sEf0JQ(gfI1IQi8(&p z1o+?Dy?xxf;#hH?2JT{6$oQt+o8#Ug3QU^!Uj9vCP;EZ*Sn=WJy;s`3Crx7ajdnxM zAlUs{HINOkdnEvI>B+0D(i5?gyNn#{@6h}^O*jO;gc-kI5&|jBQy)lUHF?|#;*^$) zdvy!*H>i`rA$tqAC$8x$u0AhC9-4<5|dYdhggQHuu(NB{6Gre+pm>5c^#rs<=}^Z?Kn(l6qP3PrAB^ zAqlV_85`32B34@PEt?Uso157e$7Uu1F-kZku~od&V(DWSJ-|M8@!j_1sf;C&^@`jq zsCVt`#9Z&zT=S#(QJ3z7GgsG!OWjqJ5&zAYcC(-ulF=T^i<4UXp^E4jknIvYwI}h> zzulz_TyG-eSD}fu7u+KIq#o6zu&&DjUV}zJ+cv$-qr%8+4Z4xd>f$j^^NEEFZRg$yZKC&Z>b%9Xv_T-# z@g3voY0KTwT3PDP4?m5d_E(L}b0MpgiEL{Wu$@)p2RX$BP~D?`iFV&0JgTj0C6pv9 zR*oUoY4QN^u2|fqizsKsSeIw&7a>uVZL%cEBURYed|RGVJZsJ?!=K`3QW0KKyH%6A zK$}%_xV0lCh#3ipMy)E{?3{7)7GD}zJG?C%wI zO!=}0>rqEdGAlmeHjO4I!)6NpzA_DeL=DH#XMx5yMeJFaF<>v^B!Sv-LcDRM3?;|` zC-*zVn-6Mt*8p+u7ay!cJjNMYA^uPU;*SJ~f2bYe`&%IX0}0|sY7qay8o(b+G0Hz{ zwa}uRY|S7PRR*CSk3+H(z;GGdtn3yhZCs2(AFiiGAu(GCE@eVHwUe``@{&rukFr{B zwU&jr&(3L1$7@wSpyeb*NzpnU{K?}pFO$XN^P=A^)D>)Ua#mB&n9@VFDOKkFV@8$f zj`1nEq)5ly1g4z~kX|$d>V&Ym^Dy}P$6>aT8eLbpal-vc+B6}FFsscrkZU`|DwDoR zq_$9Ov?B-q_Y@`JpPK(`uZAdxB&(ag2;BE-|IDS#nvE9K;Qy=II9r#|8U}hpXncGBKU%IAVJhK^M{Vge3A)FZoa_J6kV}(&=Q#3M}wk<$b+%6LqnB~uL z%T6R>b{rSA&bu@MmF+iFWY&V8&T3Q${avs%AnD$VmOw>*)aWhB$D+008z zXoSq{a<*EWEHi!Y!$-HWiz8nP)r~m6t(GTW;+b8*vHIkb<;<<&MDDV?x_Gke@rp6v z>b{fQvGpCiBMy6{7IYV~yO9t?h+6LiOuC9xe?!8BuW$&l+$(U&J}UWR2;{;6#UHzb zSP-}TyuA2Dlc}=ZoA2`kmb-DUg@*UToV-x5++E_r+9>X_msw5%Db)kW9|?_euC!VK z&w&VRG1j5OT@DMd<-A=TJspUR){nZI!O#xo&pIrD;$5*lO>Ce7JqOC3`IWP4ozc@r z=k-~9R=rwC`aE>gt)0Fu5qH)I-RO<>y@&4gqhGQnR3W0lo`1C(JZ;T|LunO+fN0m) z>t9~hKnG1rB=koX#uJ|}0bWFv?OB|S6rC$O#eX*w*H$h2_SJ)5%qj&_nL1FDxT5$4 zcTyW%W<`7v4D5yypperS-Hv9g!i5xwlX2bBAh;q|#cBXYkJzmK6+Ka@@PPez@b!XN znBtj?r6@Vd;rnnmnSV_v+4Q7qG~;E2L|Q!<58`DQFJ9`f2(Tw0Ff{T8tBO646Yr3y zSQ50e;_o#*(GZlnjPo6xjh^Dq_B*ZQRe0XlrQ7OWl*EiJdL$@O6MpTV zGCd7QKn@yj8IN=Vpj|c=COA<6lyp%9XqV#>B#!{7E$o-ZM0^8KR^O(z)&gjKHSQJw z`YYXh_U2wZG`wL3Nu-3GPE49Gfdi%vz&YP9567gNm1JH~*r)=C+evU3QP9Mw13tx% zYe1GiKm0VxJMghaoF7b#A{?SBp^ajY_CBJm*mK-;I~)T!gH1?}%Ao;9S%Mg6ooIvF zmI+bkSa#2c{nd)Qe9#t2&>0bQ#6cT0bZBWoALY`(CsZsW)`*lU*(4q%{o|(xbCJ|0 z#0X0;aGj;uD;FfMdpcdN&&NQ8Ia(E2vd|F*kktXnD+Q$rYGwRj&dZD6Opbr?S;-3z z*j2Yg@d&P6vkQD{J(2#X9sB&YY>}O(M2C`h@826Zsg)eakea1$MM&M;B@qk!fLMBC_@N<*)>n zjWz8ibcGIK5hQ)U`gY~gj9)qcvG9AplND{=nB6jfFFuP^p3nLifw@VqOiBKw(+;%j0?$BoVESLrCgk< z41UGou(oG*6Sz0W)9;j^4?uN_6=fR_TO_gg15*nQwmR3ntKvF4kueeI<%Qj9!0Xl? zOqX*yQVQUq9y8}i@tN_Ova$R`=2zpo^diF96w=e6(%TzQ=GN`h- z7n`j-pwv`_L0jnE z0J1vJx?O$fDNS0dwhj99JBAZ~WIWdqYRR994rVANs&{n%Luc1IqXqZ0pEkH{nR%>^XvgWQU-(L$Oa{9Yvb_}Y=+38*HyVY^ zZ?`qG5Ud$KqYYDieivCYFH@0q!`|H)*3AFgv}PLW#;h67>Wn^in*_|j$wxQXg3+v; z&)SXI>c;Hqn(xE(IlB`wRU9QK`)5}$ZLeUuWrFN>oa(yU1XCcOT{jE2Vp|>YTPG-F zX9%V-H)~QbMK`M$nfa{D?fC7x$n1XQ1cmGj?e-s)WIbRMkh57&(& z6HKdXvmSS}JHa5|wXVtL>fiRtpP!kat{o?T?lLl&*>(FbO`7Y~6BM#D2`s_Ma9`*Uf2@2U6#?9m7Tx}P14TI~>XLQ)B&+j7F{Z+O$yIvu- zGpK93=wP=F%%#jP?@%c-mZ13hKPrS=58=cF#Y1*yH&Rnx!gABsPY}_LbBLM=g>9=8 z+%;xg%)D`eLUx9_*{m`1DGT(4YSTuf_#wNqH-rGUw+?lex}3W1c!E<`*tV-mP_S>1 z=OIqM`~&E{UFy1&+U-qG4CciDC44yCR!1H2I~ z6cMF`7!BdI%@sns3ebt@EjyHmHfvrrXs98g?%z$sU-H$2rzfau$GLY6@w9zquDkNb z<cwDBsTW0UU^6ky0-aSEGJ5K(LmD%s++qaiO-m&v3WUL}% zH_x%X6mri5h3pIsHRfhbUx?A%FJV^^T?$3?&Iuygaf;|xONVWHMe1%e#|`0kO;E^= z6f?K~ivoYas%=Dbe%bCs`q>pTmqN_EXM%`!oS3;p{`RhzaWQjdfLE~K_aw7VjCk7EUTc4f#V z-7WXtolhaV{`MuMkpDJ8Av@CFZcs_XRccC@?X6PY^|#$sI`>2;qDGa(HV18X{cR_r z5ARSS8uPasHgDbEo~Tkz{`O~YQ%)l8RJgq&YIjwrQ`dbvl)8SJQ=jVF!cQfyi5=yp zZ=@OmK#hG=MXCMOwFTP)YPUN6(jR2;M>~`t$I3RgwmfyW_Gf#ei1$A+h-gx%#Wl{C zQZ?>w!s@E=Pj@I0jqNoynJo)??$P5iuUhsRYh=-+0MlM$|JYLd{O+vvL_kgq{F${i zoy)@UMcr_G5$6kW{%1J8h_D}rZgt`rQwG$f%+68M>5pB%-_wb7@fZE`1wZZV8Pw6{5FT>KQX~AJ1%k42$no; zFqN?1ar+d)ev@vfKIl>s_O30ly|%;y6NLQ)iv%|IyxrYE@{(*I`4!x-JZ z1$DczVz)LwJwYKmQp_}{WW$8RZuQLe>Z;F95YdhkGh;^BE`@9_g*>?PDWsXX+}*fq zn;p6TK0zTnLlJE@-_!`5NkgT4)8}l9?B>euD>BZ7KU&&J)LHR>4q;yI5R%A>kLvpp zhbDIhuU+hB9Aw?S`TGbxtaV2BchZ6DzFK7ZUm9v0Z%tqEfNKt29&u3lAz~&vXgr*8 zorPdV$ruQ242xi|n%n8;S@%YdW-nZx@q?vjMo<5t#f)ZWMxW~Z5F?)%eSyy|pMS^a z44+@)vu96yQ%~@%H@fba8W}D8FmL3e1r0;Nn`$5mtK=3|89v2N_9oPm74Np74{@DC zitF@wgqV%q;xim}pL;YXAHCv4DM$IpsQcp4Bac2h_rjmLy3-#%nKP%K-Z?P3`505s zL^!Vf*|e0EGgo(Xe7qt;`RK_TLWW_*AXGlmG3*TQS5JZ;Z$As|tM&QNdK@XA2O1-0 z{5k_&SNmxmIurfC;jTfZ_;Vu-@O7XmQh);(F_l|hGeFNu8{){CK z40iwn`B{ORZ9f)9I(z#`tsq+1I*0`85T{EZx}zOLJZT7EOomK8w+f=axM(0^+yJ;8 zL_-77zG`L`ft-mENJg)jco0&p7@-b*S{{R(;m46}{k z<(X?17b}s$1bV{;Y(8#JcdMsWR^>rfO;-XY(MUG>aD%a9ib zqkB$jpi84i?&P!h>T4KohpV^f>gCO=!0E`b;`psR0vjwLdRFplmu80js+ALOZfm7+ zby_REmhl<)39r0#ndA}=<)gLy2eO24PQK4ao!SMC+yvYi5=zW|u5+yTlt^B&Xs$DI zqoZ_vFv^x@qO<_$k`;<)ORn?}clE=FBT7yPd&cA1G*4u^I4ukVU=3fSsqx(3Id+9< zp~1g#)s;cW%Xv^;nYt+R;#YNmZXH+BCF{QNcj{|PZ~WSp`}m}wwWU6Oy|s`3BhPN` zzSJPwRNNq8HCxJ8b*4Q?$%-$TG1FUpG`oeY2$sONAANN1ElXX#Lc6Bj-@aPjR(6k< z`SHP8Z$^4vjb~BU7tdeL9N_9N{wq5{t><@*vKI>N?2mTKbs~;TO5M^Gx%V;5O@;GF zapEr1cwJZB-I4UM-a!9)f}{AuR{^5s+JM)-r2)@q>@U3qMH2=NxmIHd>a=T(&z0S0 z8x?e2ozC$ilRE7TXCS1Y4m!n$t*03qe^z$X1}f9qPzySZRxJpgX|}VgnI=i17i$@+j`spP+9R` zEfIn!I$9ZfF0y!nFLi^jpoL)YU0XN!4s5~T+Xz5r@p*P8mmJNCdwqnX6@=x~Tro;FKx9YE15O2VLb zAee*CO6DMdlsUNnLd?O90BH7L03gu&Py>1hv8Q)1X&b_6tQzPU5FsVAU4Zm(P(@YYCcF6HyY!_qtW;t2mchKF+LrQ#`H8o zI*O{wXpB!sqcJ_bC8M!E+|ioZ2%WeH95x;xij6 zT968U%H-H8Osyq`8PAH?d+u?^mVo}h~NN4T?+FYB*88h zHAS6>H7S3Gpwd;+%l0rDbvYBo<_KA?^p6#9{yF;emS}-*_&sb>bMMdFWiv|6MCL85 z_D(DmLPdAQ3f9I)tRM(3lOg%;TX<8(KOH>1^SxJh{xuIBl05y_$BKuKt69B9yzT2E zIe)&^j(jYn^Co<(*S7-rlih9(xbm9+kXQagY2I2lI1jyKDPr9RTRI=**wSSeCUg@v zt3&*y(N$}+Aj$9hTm5NJ#rXwE)5xf5A z)jC5nzmj)FK~Y|sYwr$r^0xcORx?e|NJW%Z)0R-o#GEwt=q?OC@x((c=)^61!lBco zZYw&$NAE?5kerFh&LL2jAw@vD{Lc$Q>znebyz!na#r5e4eTh8zoP=T})@}%5jb3@= z;b6r>stW4d=psok=EWbqGQ23VykQxC%H*NUJA0R>_<|!)d`80VspxPETF}x;{^K|R zqijj0gz6v*pphxUBzi1vmBBMQ{l&BVy{dRnVh9bLs5eLnE?7U-U)2ql4OpW0&{MJ) zB{kig66N2MMJf2@G14y+m`vL5aG91rA!XW~LTf7%7+RA|Lj_9@yB!E}8xh4Vu|yfs z{fk03@wJ)?%PJLSC=VuMBejK%=t>No?@Ej>L5Z10jy5D_Cwii1!Om5J@b=wVEdHe} zDYsdVXqj>==S(YP!#OBd+AV`vtp-``2~siB7F1N|PS5+uNQzmrOS1+S+8~r=`Y-4n z>n`Y?%ymy~3N~zoXiZP$A+{KzJ>G@IwxkOAY4JsMhJJ;?gTqSv( z)J_$p>Kz~4-tBhVZ41c?LyYlaFF?YBd!izXz7e^T1Tp&p4GqA|!jSS#M#ano+<9A& zpEN4QnwS|#g1LAx5Cj{dmu!eMtY|}cP%jw|K1jxBgK#Vb<6*3?hQ(0FTCf<#9tR1% z;L>;)5j(YG<=@P=hKK%5UWF%U=)2+QH zs8L|q2GCZs@rW_6treI!j=!31peqQ%$7&nwnta=3!JFIM#BT6P5Lg%6N`FOkd*kVE3 z#mBqKce~JPk<%txca?9`;g)=Uf|^!VEYig8Ftej-K(E94EN;)2D3mJQ)p4?8CqFgF5 zf5s~E6g=Vo%ZfZ*aZFiIl|Udu^2-l*Rkp4ucJZ_JtcA3@R%{^!U}DB3Q z5Z}&4>q&+-YKyb?RHV_>kd^=VXDdbImEn>#(${u?4BNsyz8WJ1>3J&+{J-T{FXpLg z#kwU4s-B81i0!K=VCGoJvPK|%-ulZKw*tim*dpYS`NdU@i$DB7q}D9MOWA(eJ(?f2 zXNpf-Fsz zRdTd57(9o?1fj&Is(5G2o#Gp}F&t)WnWc^hlerjlX$sgDf39?NJ!dsIl;tl4Ae8KY zTJ)Qxg)ANqIlaosQ}sK2no@Rl@MLu$L|OC2YxKxqu!pWjJyyE>srB$bG#`4cw^O{% zAO3}`A_M}uSxi`}+2L|-4KwOxNDQmXI$JWNT$LXvGX~Oy&yK0?7Wy0Y_*UrKRg@~R z;A3?2Pmb1J_VVL5y^v}q>VTD5D88tkml-p!k8U_tcpVZ0=XQ!c+9XQ0Ve(1*d|t1n zsx2f0;nb97#Wz&UBwOK%rA%xDVE9pn>H#IGR3NN}8A7P0QuVgs7x2b{DjMTG=#lAD zQ1$z)A(N3?O1(S8Pqv{g zX`N3`i(1qKYe%@D*HJU)-+UG!``fkzq-!~K9+eR8`kE>pmctxsT0>%=D;3{{ynBAU zB=3HGMV<)9N;zsy#TzBA8NYPbGX4JusLJRnFaFL~yy;FKStEfQ^s0tA{E1_Of8|TK z5K(=UdU#c(fALkxM4s)v_}JhBdEUEuCe~qA_~SPEfXP9VfrSNa+Urz$Lr_7JbiO}7 zvU=pUvU9L|=r}s0!|Dg#xmDcGn1e>iioa3uiPS@f6-Oq>SyiN8eN!(>tfQc}Fq!$X z&-$ucU$We1CC%c=a<-f+XZSgL>+;M?mifNA?<8M!Yo?rEEl!sGTbJi~wmiv0FIk?s zb-B+YWuKc*=Ji{bX~AyJ^SW;GrrPGsdEF!-&ztivQKP&!!!6#kTj{--TjLAdyVYK~ zb?^sy-n}`GAgr4UGC|(z6*r&~nb}#krF79zLta?M4ff(@4~3R%%}G{#TH@MYS&0>1 zCXtpidqlX28rdv}LvE?@a<}zmTY+p)UY-$J{H5hti6IlsmBT2F8Za(Ympp@Pkf^dZ zJ2rSD^p*U|;)F~D#8oFI1SP5%BZ};}gqKOYsSiqYJs1s}!P~k3GRczLDVysCVgN8# zclMJTrFBe230lTcd{ssSKT#+pH=!jgsRLY~@}6g+szbBdCH|r*e$%KB?zvWwm0Dgo zrg<7Mi#Ro3yBKVX1ZlencN!xk8_1v~NUoH#wh(Xhlpmr-wyQEewOci*3$z&#=TFdH zv#G<~7w|GK+Wq2Q%~7_L82&j^;H~G2S4VhjoW*NQb#zA`LxJix@PPiV>Ij#B@5y9( z`DUuvAa~$!=SR3O&(jAx*B-XJ47NM^W2zB59WKbOzCBg%Z4a{Exr?lefvitA>_dsD z4LIv7(>UwM1Y;c$k-%5CNv(=VkJR`oa!XXl>L)1D-(%d>SOqO_zac~Cx$>)FZT5R;dt z(Rj<%Lp0^lqnKyows~HyCBE+sXR#Q=9tBa{n*5dCm-dVH&ZdpF8H~2A7Hxm4;Gq{ zAw+OPWu-Ap6n(HG%+C5wE#N2Kn8G_a*t3BSW@Y4Hr@~=xGpRKzcGFc4BN)tP!FI`? zp{-?o>#HFb_%j%nP~9w?QM_H3%Z~jR-TTI~@X{Sp0lFQ1e!ix#-M_8I1CjN@c<^c& zPY7Y)=>Xt7wgc%^mGs|fX#%}G^_j7`c~)qAx`rKXF!CnnUZPe?yTAFofyTCz|N zUU-_&f2t;gYZgQw1g5bR?=axX)V3>Wf)ZvXn2O)j6JnqWT6vN&dA`Lv)EhIfn+~4t=4S93_q%E{xaC(hgQcy_poW2lLt-?=1YQ-o(U2Wb zcUm{!SL;TDAFZ*)xUI-xE|nGiff}`)t(#>`lGYu?0X#570FU5@v%}aZQu^O2l~&=^IZZ+Tne(;d;e?G3v6L26r{Z2qF&7Ca|GVwy8Kl_WfCgk$7Y#_HMt5}dQ zd6KZpo?i#M<>BsiT(_IDot<>*P^Bx0y9Llir>+j+SDUxz3OGL zt7*JhL7CXSX}zaP4$|Xs#gr`wVH)vwZ2)zBXzyq^#?bQRVb$4kmY|z=2QgX83Dt^d zsK-Ko_80H7Cbf0M?}gdXWW>D9(y={Ti=qEe1*r**S`m4Ts@j$6l^na2A0@2$vzp~{ zrl8;fg>|#NgVEVL&LWq;(1{ZBbs5Qw6i-8@jOh*D?G)cWPD5&vA1rLo2>6w~=ZQN! zOf^-d2;33!ty+Z<#m&S{{W>Fy=KH^`r&#LhlKRY$CLLKcySUv`ZJwg4q)^!%e7q*^ z4?TZ*#$}vHh^Z**R_50;hZz^}xzCcHaIvlh%+83C_%lR$_k1qO7R`uI-DKisc@04* znvx`dP%Ox&Cul3sj^`t!^hQ}I)4zAGN+jUJ5R&gEX1h{?O_4tH;GFggpaTG}88Kt>T@N26~2 zxrz2v;*)x-{wDF?n+YM8Gygli_fXuL!EAAxF(~h^v1V4uyNBaoc%p);4Q7o6;Ve$r z(Q{d}JX4%-pjPcbvL?1>ivQ~3%9@F-N^mBfR9R8SyTQr*KCRvA@Kh2S6>?2b7=IbE zb7V%@doC!J6ad4K+hp<}$3JP^cLh(gp?>8}0Dg3Ebgw>(UzQuf4H(meNU~c~p#iCM zZj}*!GxSgySMKj*llW_P4!JlN6WKnLxY&jhx!6{PN)kKc)5V6b_^_PuD+wqf+cM|V z6c};IfpDvf0pXw$0}kPu6fnCaNi-+h#F~|271^@;Uf9A=3?-23@iC6W+<~>Y11J)+ z)rn1;-07yxo7@};zM9X4CiTJr%W)XbhFRUv(14Gxk5tzxkl;fTPS^#xFgMl}S3{iw zO40q_gnl5NDL#yxs6 zEjV|Ox{+P=`+Cfnl%J0NP}T#nIm^}YZ|Mv0f0Ra{Gb72^v>GH~B=hG(p>qr3VT)Vl zaW*_2sX}Y46P2KPXwS1=kv_tl(LaGce!iyC0d69BK^A&H8|RWAwZxAv50>qw%$SK; zlXqC`{o;>ph!V3_{h=4Cg{XQq5xriGaBnf8-ZJK@B(i00w4tmpA7j4LAv||5k!${6 z4jvSk(!~JI4!7h`Q@Q}2Mt{>OUSXb_Y@GUYp=?8-=fVA>FI5jhatZ5bpyVse-ly&B%7C~{;Gmbxic>$x{ z9@+veM{K=~x>3tQjm&H$kY`FoskVJ{XYigp*Ooj%0a-h z@-Xy@^NF?LfLXTn`PRV=%M?ke1BaTb;TVuAr>^6o4T?Jf8uREEB;dQ+_E&)_1!{nJpw>_Pjt(;~=#*K>--<`miKd z9CT3|O&F_%;hstjL)UGY<1cE^r+06&)q1DLP6rM0iYMGuVn;3P49rTqZG(hq}mmz=)5mDjMY|#{2DBTo1qi0Rf(iRRZu%C6Y^q><^P`GtF8)x$dT1GH5 zEj;LkMh@uD43y{p9^_^#PG)tKy^6Y4u9S$*jnt3)s} zGsxbHrEuP#;P3=cIJKI}HC(ME+L2>_V7L#`7g)xKqeP}4`$yqER(pWp|58~uGT35c zyZ|-F29~qp+b?%Uqm}UHZ`Sl4u58fsBBuOk&6S-nuA!5<#XN#e0eT4cdLYn{&|(~S zy!6C#Qgy$!ODitsB+4qA)|Gh}@Y9(pL+cbjC%L?wSq$R3pG2Ux1tD&z0E39C>=+X~ z8BBSLN%s~HV3U#S`?D%pRR?|Ub7@!6C5U7MdM2r80IG{gMN4HTg<7fT`a^lpzaX3SGq8K3G-Q>u5_(C=Tf7q0N|?|Ad94A`H8G}g{xSap)%;@<~^y!@M<%L zT)is2S)8<2*UNMKiRgMsV~hgchU<-!=h$l4<yc6!+5KU4&S+`UYnQY$U#3?yh#MA~SKLz^)bvo5Z+W{b_A`ENr?emZc{up06-p50;#$$L}Vb?THKY8pB}q z%+;7z_S%WW(#I_{a3BWE#4H=9#{SQWTN;TafRq=nsIp2O&ni7+eLS_+havDpYgXws zt+Lq!qc#62(YK)p0vXR28CdPv3cTiGVVIUiHv9oQF`-aN?>{%Tv706x8sc}W`oei| zLcY@THtCE1wL(yx0sx9}*qHOw!C{aj4r19H1{X+yul{4z913Mj#64h;8|Mq&kAl4T zYnvN#<(+f3Gv@4D8R})|lgd45%!q33J6xOJa;>swgxN!>=(O8Bv3J!b|ID0hn6gOp(;rAZlY z`-;QeVsx*X8C^lsOwn6DUvHTk7#i8=%9u^CVd+&a8jD1eWE5ap13*lCRq9#*2$-6O zmGJpkU$DP3`uKexWEd=KVovwU4j8PnuyTpueUc5|8%AP8@%*|ygoumZ$ z?mM-{)eo*GRY9+sBx#f|qVI!sp@U9wUZl8eTV^sy$b#dhC`bk;1D3j_gS-$I5z?x( z*Af97XWZJG9X9Ncr-fP)z%(nm2++5uG&I^Ra~1_zFIuWK^I{641YGY$ zEb*ANycu5yz--tx9%ur=fAOFtr|hVmxx1F(5f(2o6P74ZHoRwMrq?CPNhw&la8>>S zt?l6Goy8#%GF%xd1vtyp$bR3TBGK6(wr58Vc51ex<b z`krQUc-Wp-d}@vZ5Junp2H=B)PN`~;J~^q%NBh?{+Qn-)8qNnXTpU<4Y!WIEgvY+9 z$JC1{fV>=(^D-x3_km>RJbzq@F`@-dtE$hzW}8OvOCm!?Fw_WA`(LTG|LnzCEoK53 z&utFkeC;7l@>3zfk)=Hl^N{0mG`MHbF7yOef$!-4uV~JLBK9~x7`@>Ox>SLIEm3{e z=}vrD4LX`ayNt-NP@K5cKoKxfn>sHTP`WorN~QegX`|e#qBfMR8urBiqGkPS((@QK z8;x&@qMecj1E=f?#{VqvMN$oz4U2}@@h=>im*{p3<1bzs#&dohD-k{UsAtlZ0= z^c!B@3sB=n_C$aZv!fVGQ9d&^baD$~}flVL}K2FD(e^3p9Q3IDkSLAQFa< zc6{s=Q~~3HL$sV<+UrD&)w(c-vxPC7E!1(gP~nUQ5~v$;NZo?Ry}~1d(|i)V2cjRw z!BEXZ1SGHo#@VP8MJMX7UylT*ceEUD9&7F+=uKVjFQ4iNxu`lPmekq9iWdZSOrC1ve&&DN-_i#mS)8 zNdEDhC@M;=a=}6eD_U5rwwC9OLl2V7=}QjEn&_J`Ge2Aq4jG!;6+GBM!P#rWrFpg> zA03x&8O;YvWL_s*#!Iey=cUXW@En7t!FWB03LnwH6DS2kwBeNz0!;RmavdV=Xi^3V z*Z_xSc^+NU8Qp6Gt*gR$lc92XFeRiCOr)ChbU;)JVZju_!n2W(S-BvE5M}w0Q6P0m z5Yb!7QXF)J7dzh!45WKX}JWUi15qQ!q3W0_>Nrj|2O%q={ zV@%P6jARyKO3=i86cw`*304gzFmvcI!uce2^xKYvF|mII?mC|OUtMNikdowzC@0CI zpv$^mP^6^%Xp%cq{h@0ahv}aw4v`MJo^XjeT&uf87Cos6p?+Nm)f^(BW!xc}7=ZXU zF-)`@lO2f=I-wEsc`A(D{GwHNmQWi@jJW9*@wi-}KQ#HYo-5=&kc}Q>6d5u#RGBE5(u^hiBH64WtJ#qcEDA^!OxR`bJYLp&r|I(utj*Um zd|iPWWlruH?jMX^`vvtJMPXm(71RB5%;un_koYf*mD2c>zeDP zsm*cA4IE+N@1wN0iFM0CeNuQ&3s?yeih!NbRYP-;jBrHmn9o=>`-Micf)@}k{#FjA ze-}t9$52wv)W|6XB)z{A3QSplad!3o4B*rH6D2|vsXr%>w*Cl!YW3 zqXUyP{H#evVMvKl#2{c+{PIjbe4s~26H~C^X3OS5F?C65BW1lJ##+3X3sc4<1;d$pCdNAD!-PGy;tQo1+>a1+>2Pj+&7<) z=#6~BeP+Ov#b_nO@R^f@%|6XfEV@Th7`d94MRD5dDFDDt?w9OS($mPka`$LFE<|X; zZ62>OId+fWuDQw5bI~T@BH!+sr3NxJ0vGC%@2(IeVmwnP`162;zD{J`x}XP4;uAiL z4KU=^O2iPm9I25h7&=l%kg0+Q`-q>FI(kei#3yzXb{cE|3!464Mz&O3(_ln-e zL(vGvhTR2pM&}!L*MTvG!j3)!qTB4Q@&1S3Q`06=BR>w;BD-#2lo(q#+F9 z(7jQn7WWS3Ke03?fvlsO-H_X>!*+cv?f@cjy1}lwaghy*0DrijBEHs@g3ZXi6kO%| z6!YOm1x3t&Q)E6hmy8^1jsUeZM;x{pIY<}_DK}nAA!U0F`p`5Bo*zb|;Y!5aaFBw@ z9zfqKC#)G?-mA!SbX${Yp+yvJro{v;*pc40@2eAmun$T6M4Y35V*y-Yzy>=D4mI5A zq1(N(b|MOeOoNtMGMzuArMA#*Xz8pgWQ8N0F80(LP2u2bc+`6?k zqa%i!crwMuzh|2EZU*!B5;jP5?8H-TI;945VBl1bFCuDX4G7&W% zm+dosU=sECkz*kkXkkLDgEv*OyicCJgzKSW%dm=Rkr*&UO<(Csd!?qW`%5tujl^P&O^l>3AyCmSi3$-0VMcd~P?_s(^W zjZKyk946i}*>avK_T^{QrfJD6A=2lXEA$)YYS%0RRYfYX8j`_r+N5$!voK+d9D2Ao z`l~8Geb5u7eza}=(v(5pFi~39RRPhDHFdgwGa5@a;v)@>^`tR5HCOo4iYb=ZYFU_N-7MwY-D7#Wwb#*1lWeV%BnhL8WR~iEZPhzh6=L*P^yYv~4Oqf5|Ah~30TP=1H=m(*GeUbOIL6YmIU(1B~`Hl5n{SUDmyI=O*> zq*NK>Pg`}%qNOi{=0#z2d9RZTPUfghsfI=am?IaA5#Ei7&^#_8h_|X<3J0RDY>HQ> zPR0pg2hSS?CF1y;g{c-o(p{Arb~$oQq#2_AvE`xU@DOM~b2-oJH&Gb=Ivf-DAb^_2>@vUY9T=@P<{|%)P#lCTjCCPts|SZK0P!h#^1uz+Y!MoXZF?M}PC<|&p0 z(Y~fif+P!PE#IPdzOhGseJP^VZt~4xb9C>i0Q)G6VC|`Ff7gC|QdEB%()vOd3B-YIbx7ajLax=FjYG ztQCvOTZX_2y^keG9%v7>N{}h@@PH*qqTO^RTOJxCYrG%34UkbCl`N<0W7^|qGF~OA3bAV5{uHkvK{Bmc3|IW<)a-;Q4xGJnom`?$+x&kdewkzASe>s;XIR~ zCCqM#_WYqBI=G}}lTB*P2AkBI%|>m_$~0255<#_Q?`t-j(mNsmYr3Nm!((om=B;gG ze_1h|NJ)_+D-e$m~wHO&Uu(!Ht@_8V#$fxmnA4Ig6 zB#|S(KM=m3gZIzC?&eQfWX@SzvpNS=nH57dN=vwDUuBs#6t*${=S*n!qIGLzY>}B^ z@(b%6wVstLVilB4E%TGp)(3r9tKM?BzvMJEx&T)imk} zpjE^1#`vvDX@uWkJ&)t}RUjh7--M#VLyZCJ*Vd5^(?S`MjYa|KN9s6lWVLn}Ive~5 za05C8*o4k{-C~`lE+lKUmLI#q3xn=koKdD~rk<_Rz6YDiR&8ttmvHo~eExPb*s2mY z%1l8Zqf-qtSXDifOC;JdQ{(-c7L65jlX1SI3>MS(IvaB|d~uk~@NGu=cm#D|6^snS^|v8*bN`-8Q66SRiPogZZ;;3B~B^|0u;9OZ)q(g&B*S z<+kR4E!t%0N@JE1U>e>(MysrhHZZd(Ua=Xg?79>mJE{T4QN%ch0xVTOUv2awoS!w0 zY%`;d#(3Bj9-V2RQYpr1RVx$7BzBctnwVe2s3F@}jciS-JOncUzrlguLd6xqvU%j8 zvlEt$6qtkrq(EycLdr6t=y~;~Z*6PZ8m71;8?`ly99G9(Tq0EbrQ&s_E+fPg>xhEP zdW+`3QDm(bPRnRIUx@u|*Z@qy*==618w}WOY}KaDt;*?F@7;8a@eEortTLl3JjX zXC&oEOdEp(h(L(o#2i$>NY%JBS@`J#k6}l$;rxN=>?N;3?yTzKp%L&IiK~Po(OCzF6 zvS?<_2W|GHC#48aPJ|~d_B*@P`iqS<+e8UnMV;qg{h?hi}Od@z>7Gqf) z-5ttN8Zj1?vNmHZDHcKlG@}PnJ;$}0H9|<0yB-A5(i&Y<@I;S(*)c|zVRn=NG=Ibt_mA2p{hs+`n;uSX*2niMf4uqg1(IqkZpmDH6Isy1|{!DO>tpL}79-okE zB{UcdZm~3O3f7+TWeWs5u!c-GFT!{f+zu6Cm?hW|%X+|u1dl}@ByTLm$I49wJ8p}% z)lF8RZ-J9AskFY5#-q{EG|jM2s#pgRpJa%cB&%W_D&-RL9mtG;&H>1jf?LWs+6!(g z95D+Xil$pz%*taL4gAysRji*BLIQq5!L6gG5thN@wAmBaYs6M)ms+eNF))$*JMdKKP?^@q?) zV^Piog5?XuSd}n)BOQY0pWwsh0z4|!Yn_{QP^+As3_%R0R?em@P1TZ$T*<4p#xg=f zUgT=4SK2FWo>Y0>4N;NGSKSmIXa#K~C)cV2l}oA%s=czM67j z@*xTjAXqfwJ1awKgfIAOJeXK700WZ)J6Og7?wAP&W#Nf$<|XT+>4^+2>z3vhbzt^T zUxPgGY1+)~A^_YoRyVW2f8K*1+C|=W_i3PSPIKgIMvwoZR zOvXAe>wlAaYAlJ*y&}>!BPwhRb{3n(+NG0>LN;3T5BAU1RMLWl$U}5}gGK*seJT_g zg_fih;#F|yuZ9={;OHMKK4ZGaCxfG8w8OIg$u<5&6qU`@B20+H-c9lr^Cft~2bNd> z0kL(Zgw5aY$N=>P<%>y(xTu+rA;@Yee@4Zk=%sqpMbNxuxY;%x^#a>PQJ&&&W1Y#csmX0?56m2W!btX2hw8=2MxULh#wtHeT}S6hDUcbQi(9y9&1y;w!A7C=Uq>V)bwAZk*%-pw_}IT0r?GbGCUhhG#3l@3D>avW zzI|KOU|QB@4N4#bn6#|Tfz)O-+hPP;pVqIBFG=wTBLSwdK8>lXki0=uvY*i>twm20 zWL2+tl*GkWk;KJ}^I65nRnR}kTN_J9bi`=9im0t>e$f+lkfD(3iwS9z_R>nRswHqZ zbs@VqBm>H$S~9j|iR7~VT&7vscC*Hcop3o@{h^XoC|28fd|cm^iE@63WRuFI=s|DXjKc( z=(^nN;VZh1#Xc4!S-z}hmfz?CTuCs*`H_G|sVOr-t6iyhHHI!UU~LzcfmNdrFDkWYGs|_R9ich6;9oUn6~}ShVZ+XYwzwzZo!*}y;y}4 zf>=7SDR>1=*VF!PtnP94;6ZjC@*141B57n|*coi2z!f+foo}f7&DY?J_iqkHw1g#) zpW*8M5Hu&ni^^AA|9}Ut>I$B#EZKYSH0|DuTY04c;?fGsMeP#Qv}$1~qr6DBlBEP> z4+zHCedz4=tRgGU?jr2X}{euS#OoDTvhPHkSVAqMSF!<5&*xUN;+1&^AozC)zQs%eZ>d=e61B?%fa z*`(^4S}!x6m-bSS@ido(UN-NmX)IDS+AGft7gsb9-U8}S_l@-GrAwU(td$D~Sb>^o zdOBEvJ7A^y2zM?P!L*aV1GQQ4l7Koj!jvFtlGBP$T3|075j;TzOQ?7W(F@S*QU~d= z$?_Id=Z=mZJyO#P+Y>$d&~EfdzSM5?Xnuxjvo>GFGv5D170+bugLsId!*b!Z*d*HR<$TuK~SJ*=ZzapL|5iKtt| zMz-JHunzv2#Ba2#pRz1N%7;dOc^*S#)D0Eff(~s9pdQPil0Z8VLuR~kA`5^DkEBK3 zHe@XlQOrFq@(#(Q7En>7jJw$(bR2v4Fpu?~ijAhEb?UnT0u@W^7*K^ug^$#3L}YB& zb~{cDreY`?x9CiP;JB-ic#CD;*1nTQ`LH{KRMn&5!(GACspaBW_~hmBI> zNySMHT}OfERoW6XDjk9tVd+!Mh=x!qmRGUT>eOmVtXOoyqGxJ3<$l^Uw?~CydPE_` zK$==Xo?1>@CEIvAalFI@Ms1rLg+>FFOrzr{1$u;O{PUewB9RBn^v z6)AZ!wH!;764@_O3dxJs)V#BdRZOVR$d_|7#~8>-IiOCPf(Kr)ZrP%fY!@6d0}ocJ z|I>UWsUumW)B!k&70nOmXUNVbPA4*?G!XG0#R|dujV{$J6lB>T+eb(RNknb-E_MOj zP+x-(s}&?EUsl^WSVdd0+^AWLRTS@wh0Hg$mm8gjazpAxgD>dCj1r>WO@3Gk`L3!&Wvd?+QK z1ia;PLgBJY+5~psEwBUqF|aGFSqHlnf9T2t=o=KN%)?!dXpd~}YIzhiGdW~_ipjBl2DvuSvxA_|j{2s5IFzoHQZ=i#!U*NKYt9uC>i#3VHEB9 z4TOAv^rFZO}FE&QL!SG9I8pany}$;sq~l|WLASJR!1|oog^iTyR90vP1pzp z5r|{8QBl~K4Z9t}W}+B%^TI}HkTzihh=Z^ZV3V*>QnV5_JQU5_rgafZQ&lB$Qs&2| zN>dSm5>B4vL|A|4i<=!<&0do=+mnxc_vXdRZZ*4nx!r2^*Q~8|SR3-4myi6}y|$s0 z&f8A0+)Y=pCnIEP{C0d#>?*`z@!L&pC}p+lH6hVg6<0LfH>h17?|-70?RoAR)mCBR zA>D`)vK@?7ojF#~MtGz6)U<%@cuAXr6Rh}3C2i7wAx38&I?6CP=kVF})bfTv2(R5} zE)nCHaET6Cu@r5k2$YSsZP_OAN?Tu&o+QXI)+?(rPlPonvSDMZ^?@mvQ_3cKiOQ#S z^pXm4D3ZhRQq_82Xrk&U8HU!8+;l=yDdNj_O}-`Kdwq`)Zd-dSOKYP{x;R*f6>I2>jD z;yWf!7ZxNpL&?Kpe)x)lie4I@j-`h1V~}h8>brXhat(b&r!tA5WQ;Y9X-_LE@t)(8 zQ{gEqfb4*2Ujt-|H83b~b+@uPRkJvcWM#cN&seE=uVRIws&ebqc};J@cC!+BMmBcu zpua_*SYrtUf1}&1;*(&s+G0K55#f5mlVOub(RZ?H7kF9!Ch^iKQ&psw@5$i@3R*-H zBfr880xE2VeonuL8r1~}@?7`Zm3Iq=b z1UBLzC?Cs~SXF8H$1YqSKW1%g(SeOh%cYIaH?(o&^_#qFdeT_uZH2GNn4+m!710WPjg>IzhvJ!n5^9{P(y zBE>mP)a&@Mq^eC4we^Qmm%#UvSu8)8-f@Ll@A@&ScQrq$-Ys`Errwiy3U&)qnN;xc ze6`Iec>H-SVTzE7a#NDbkSD#b2gU`fMQ5fM7*X%X{vA~t>V4834U1FdFtrU#%@(j} zvzmB<%C)k;9=vJO`>m?^J45fsI2S6v ztSe*6s8&p8$#eFjRCbq)PiWTNCF5GtD2K~dweKz&M_N1qmyAbY;fCuXwFmgRyGzDB zJfK3Pt>N?uy=461zQx(Kn^Zc;tbG3Rj4u_8UTN70B}TJ$+9D!gb4d$d=Ip(GIrnTrIP8kUu4KHe^5dBiPS3>1s6pxkr)NeQe^}0xgx33`e2MB4%8qOv zuQEOEv+en)HRoz$sR{t*V~uk8UH0nV`m27NB+weN0 zdp{3;8^=O0JZf(=2W&x;b zI{P*-t2VIFrIDp*ewUHiA{UL!;-PV5b3U@w{%v7!42_y;0*Y$ShNOcF!q;kaqSrJ! zi)rXch$(@~ImOvo5G_pbl!(jb%AmrQ`r`C>Sp-=ga~V>08si&$W6;=dHM==%Rq^0v zx2l*FA{$2-4-iYX0*?00D-I}hvr&XmA(>MRG4wrS(U<8F#_|4jf^mwyNDMv89S`_J zrI6R!VADDcpK+D&<1T^k;@6wb22*H+7`3X9%KsnrWZ$*R7T+dU_8eQmFt3C8;`$BP z*qd|_Lit@D@@Lmt-J}JT)n(efi8^8SMc^&`i?n+a-xZN;NmgAe8D`56lxj@PrDcBB z94I1`U)%E(hx&5rtEpgWZhkZ5TDs&`%&>Kjr)ep$33PCxVM2!-Kp_CEC|6*E)hyHY zs_7)Te(lXEb zzQHK~#Nh$4&Zr?A$95A^5p}v0p;r^EP3hz~koZs>6&f?Is9q%Afwv}>-(8tDL|xH_ zs3CvGmJ1M_7k?sGRqag;=;dy5p|`CAB{kB9r~^clmR#5_s@HZGgBgJW*iO~o0xGp zX=QT8)nYqkm^L$4FK9QDQxncrE*vIoqxFnc+pHTTK`Cvcm_2~>@!7ZZ!L;+l&aQN? z$@WW7>HbfaF51*yrtsu$rF&01bvK0e3S5ZLzLF2ii|tmrYx8C&7UV)w4h{L2?7hZS zK)73aiiW*38!4ZuNuup3J$nu{H0x1ub5kQZD z1}j6nY*V2!ZR=i>RDC;Ca&u=bPYj@8=gYuM0c4<^&*4Ej8+Pez{NX8gqW zY~SOZNQNEJUi@q`idMzYCJ&~xx!XqX9gkInhy|kV6q|?;xA6Y&{DOkn{pviU>teL* z41h7;#E02dM0X}s#-~SB+1RYd*KQf;a~66b#^~_z z*~bzEFZ)f6#LJ2op5a|ksjuhws@;FJySO%Iv9IyuA73JA=L6GzBL#&)3?27Knk&QZ7L|b45!Q4 z_#-XFDnkp^R!ug?sDLcwlE&zy(>6vsL{oH{|7dQgFFb3>K%Je} zJCJIUq3cU;#mL6EFt(j6=|d5uQ^3`R5)P%hJ_cN0|K;(F(LQY;V=OOXSH!hy%jy^f z*{UrlHteWBttssQat=12C4&Eok>&RV8N($Fv9a}wHH~BtErwyXoqoB`iez9BUX^OJ8B!TN^iw<&OqlTxJ>MECW=Vk{G~|TqF||5*bau^-N3o6ab~tS zYL7FE^`b0^^h#b#m!oWom)R3Wmm_z^%LF!K(_`@nADrU6ytu`!VgPl^-Y^gcph`yp zj5uB?Y>PJf7B7U5^}`YeE@mX&A2I3BluqTot8}8f$_7}kC8F^|J)i`OWvjG5>>IOB z@mk+EW?o;TzVaY7v-9)N*l7Mx@tL1rTkAZP+1jCIaXmp3ESDAUh?~cppoT*sU`Y^L zDvoH=h);mbuzSotIF~>_fLA)EQR8_!^QT4BA6cX0N)W{=PYD*k)xbguk8_%F_QG=D z`|%Cxr-SWd7{Wo=H3o8z=mO4x&GUztaSA=4_G zQU7iAP=LCT0~9v29mmsZmFb9(?_nI!$VORKk}sq4HPdlkyR0>I%@(q(+E6c6xYx6+ zt5i_%pQY4<6s@z@tn z^|l&IQj4R9?E2o~j}`sblj=ThZ7;!7a+nm;;F@;W*FJMLxMaO_wRMcy8rneBl9d|# zKWXr(B~~|BOTotQ!_XSfC$%3FyLx^v&kw{KW+$xkJoK;U8|UtX{q7f)Tx;NOy~B6L zDX6ipp-crK2TOr;c{SH$C)n8M^bDhkcEYR7xV=yHCB-R0d1;@OzlD+O}?Mw6qryy{JJ#5o0-C4uFpevLRTE$f7olwk}Fmv=?ctrey0R z882HI;P}yXrZ8fUP2FQ8xzDHv8(c*(bxZ+p$3@ zjbm__KBWd(lzpXus$-MADd@@wHKo?m8bQC$^lc?qB0m$~LGx652Qd<4Lq}|B=ToB0 zufTM`cKF!BTs)t$p?S_$H9ouyr%wNuw9S@wHQVe)LXXrm%tC$L{zceG=oyeLAUU*( zf-#X`x@JPp7%LQ?3;|V$%oYh!JM&YrqxQr_f^id>P_gFG2S1!L^Ao5lmW|s0nUBaC z&<~q(ne~8x=tiP3Y*~hKfCz#IaHPmc{X*A+PFj-68Nv_IrKL#yboNr3uL{#gSUS6-jXBd_uH^q3`)2su;8@sqk2A4^ABT9nULz0DkrCDxGHeS+u$Oj@&6_av? z?0C$5E}8dLCx6O-CgHq6sgAZe>B=B6`P|SsZG&|gz3IU+N)47VYq04o&wVa)_chP* zY#VG-^3Lll&wWhUgsrIv6SD>@GxY^4W|DSgYdzl+vm^-BhcA3rHs%wJ_brK2+XrP6 z`?8&QtE{Wv)}GlAufjVaICKHxv|iOAX1&72X$gf8<5i6ZlFc`X6a~2HZUk9;yH-Ne zVa}~b0TUxr`HX@(CdbNSg&lsCSXVk3^qveyU-@dO1s+ZgX0=hIwWXcec&XZ%jkU>9 zY+Df;UAVn2zZ{{KlPNsIU7A@9v#KqnbvO6wIU^%nr-1u8>M@Si4hWd0wmG1~?yJqm!kF-jgwCT{r zN`y{5vZ~d#P0oAMJ`~|7a=<_!5IgNl!ZtcMn2JdZU7~#;ZA=WwAoG~_f&Bfaq{LHx zbI*bZX)~tV^G%*C=wf=Kw9}2yg)cE~Pdn{HH*FX@IFTP4-LY1QqQ0e$>T&Anv4e>L zG}uOh=w3!B!|tp`iYQWKSf3Ask=N5s#1hT;BZ5T*eojp@k=`h*>P9b3oF%SyYFeye zZf9jWPl>iWwwn|Y&4w5IXb_7Aox6kUSa5}3fK4_iH|=p5jTE- zxbY(yeOi=3a)wym=>6ta@2QeaH!8=aZ4{WZ88Y(1U$9gRRy(N9#nt?|PqUc(12M(p zBaA{-RktpXeJJs|S~<@Mt_S#heT1*q%0z<5_YJ?-*l!ebB+>8voj<0*%g{M;7Wk$4>;x3AAIwq4%Z19*Vhjmz3{G})S z8Sv2t*4uc@-0b(N$+Sb1H7WH3lByk|9CIy2_YWu!MPGt_=;?05+I$gxelzr|p8hUI zjRG=NV9g1)!2PDBCpkW~p^}gPoI=Jn{s{lrs%`yIwb~rNEgGne|J>B^lUW39Q2KLC zTUQMx55k5C`HIl?1Kd4vPb?5!cOKFznrRCHCb^$Eq|l+b9{Q6I_%S|wAkc9YFLGoH zE(|3)4|jYKQPfz|WTC>uA##eUwrqzj(M8o31RF9`)0$G$SFB7+gwDa%;rt=7bJgs( zgi@2iv1xwUFqezf92qjoM{TWJHVH8n$TxB|R8VWYIc94(j=4LvRgL+P=9s_L9COO5 zIiVRqkUIgi`KZ_0c4BeqXM{-LXq$*jHI2O?-m3g|yU>wnSHF@vChh}3V2KEj{Ye;k ztu2(N{ws;1^>q_ryuH)Ic!MNbBRg5Oe2{Pr%q&b0O49>M>X?*(= zSz@P1r(9;Hm@?qye*b!cuffFw0OgbXDsn!iZ6G&f_wtkDwp@4c6kwC)0B_2a^4D}2ciPrWrE7Fl&~Ym6YT?$XTy#&3ri!X| zDGX&BPs&pxB`=BMD8z)9M5G0n@SqJ=8mm!)Aqtq}0dAtkCMb;wf~3QPb`qt>(4ymj z0*1`*zt-OSoO3^f-C2` z`~es7muQw_Mj*=dz8Pvd<6JpSX>hh6!JKlMi6fr|-&}jOqjq+wh4p8b2}Ex1P>5bM z)`kHg)@l>4yh6Yr*6=Z3X7yanjjI>dNvr3&xEz3SO@~%5+|`g)FD!RhJ#s_U7SC3A zc=2v)tX-qZi*4^&G3bT(;a0MPL2-Y4lU>U_Mcmd4JL{N~ z_lfyT^Fkby)0{3nYZ9``7Aaeq&@~QXTqKqq zTD0R}juCdvOe6vEw_V7hf-DS(qw3}Rt*`m~N9`Q99m^YtM{(P?$xPu&@DGitHiK`& zs?n?tXlfR>c{0PO zJ^=38h2lKcr9ir=TrAOQ_cc{PS7M(e@Ce(uAzAh+Y=G971t$3m267P^9+;Tl%wRb# zFezOqt_j!dzn2x^Mo>^5oQQ%V10fs|+$;F7K{A>Y6=Xv+o9$AzHC!eBpvlU0$DxaF z;%v7`F2D#pm_ReAd#0R>pY|!>vHu z?DBC;t?X(pl>kghB^B^=u zx%Aut6LYt$1pRPlxslh{nVXDaGnc}iX09`0W7C#4cN2?S8Ur98z?^;iG*v`DjMUsW zn>pA`UYljcF>`>0uOQ=TyJ97+`SoP>e$ie=a-z0Z&VGe`h&#Y$SXRO6uvLQM;BYW{ z$D5HpY@6eTj%>k(n&(B6Mm{5sB>5E_xOy20Nq@&>A~E6yhQTdq5i#P?QjL{we4PDP zhK7dEO!7Ijuz{P8#Ejg|ZCnHP<92S#5@~jBaff8*ruUkidr}g}yZ zbikR|bR|~r`ZbyommZS|1XgrPyD7ZrbojiK^&888!cdzcJu{gqx%4i7V3Jfn?!bkF zpVQI8J!0ENbAwdsBKc`d4(Hne{=AEI+%@pZ!aZbTK#o^rv@B9)5SK-Pk;<2VNkhcg zG+ac(#?g!!HB924dO&m)!Y$OA8Lnz3aSQdo+syZzP{ zG}*-MB!z)QV8g7yU#)o4Cf>EY9ex-EV3K-w<*u3;YGQ!W)oMFX$MO%W|h(w z<|{T%y}%|uY`>mQ(20H3tm316U7`J2XfG6w^BT??U9**s_9a9F$J4y{F6*v%^ z%l*nSeUCey(UHUzvZE=&2vN;E#v?q)&T7>ar?IB*rs=oq({yunYs~QkrMLn=;cAyQ zS2vpt8d2KEPq0gl`dadia5 z8yqoKk2|a}V`fUDHtppVxn0s&9acZ`riw*4R+!Nn^oZqR2J)OmBer;ixOZd{b%VBC z5pZouG@DGf*9j^=6A}#C7ePalM|5Xg(g#xRp=&C!;>6Fu2J>(}98NJmbRn=SQsZQh zz<}(0Oac!4(K|M6jlsFCXM+Z9CKZj+EE&+LZmX3s6c9xtwalc$yuN(U>qH~R51&<+j^4L&V=!w6o(z87KxUrjdfa|@Pdw1*8mokO`$MFYFQHtFx>?cW8P z+Y~mU35S*~j_q>xZ=uMUh8!&)@W!G?hWoce4{;Bb82vr)U8Lv(j1nPww|{V2j4_)D zoNt6rCl$Yf1P`!<PlPWDPiuBFbVCY5-E`=hKaTwB~E{^9J|h>HBaG!Qi($N=G}8j*vte z%c=t@lcb}Og_UR(7dEb_uWvQVBRc%yOPF9154KUI>C#%_Sb)A}dN7aj4aLu$Fph(nP zvSY^BY}(kRCG!P|E$iq98>JoYi+67L>e5}qri+bUf|smd*fk3u5;324V-v`t+^eW{ znYn)pPoPS6(rHFIr{%3*l%%IZTl$az=1T74l4&LS(UPPyF_Q3Eqo00?t(g>YoouX4 zck-tE*Wxz*3QS5&#cl*aTXGNcE8@l++6l&Tj~SoWjlq@AjVWyd1lna1CpeKjl_5_EI*)v)Za>7apqWy7+6 zbGEC~b+vdBGWJh7I|BUEmGId7mc-}=DH`=5yD5*qJa7nAE=7yMnydD52SB!QV!Os^ z=Cs{L0qZgcKt?*OJMASmUgjK*vDi4AhM zKeB)@EI&MZ=RaN8Tt>&Yhjn;01QAu#uoei*0O||HCS(s;^QyBRnU&8{zM$>d+5^%d z&|)(Q_y;qOU~o~O#b$+NgyWs5OJ_9(P#ZIH;n2$_oY~7V|Iyl<4W=&RCh1Hv?zoe4 zBa5K*tIN1L=Ehpc#V#jSp28B4j&L6`HF$T|fjaKYoIuZ;W|~s?&*fVgcVMp3imX%% zW{RrLcrf+o+G;4eT7?vx6G1vjI^ApdE;=K5E!EY77*wG~l%`s_>0-PVDhWv|bwyS`6dxw|bgyTs-uy4~&; zlaoDng1KNr*8!ZsL3FXk_GaccejUKb07mWuc!Cj%@vUj3SPUBOHh#;Bu5y{ZHIryW zIFH>?hvWA6;bUx^;+eyqI8f40D?DkubIcv3W6qtpgD4$0iOx8T*HAX?ooSjp(e&h3 zlbbC56K!$iMAYDejy|Z5hU^zm&Qf-_7>R7`a%@`5KEH7xddD-flU7wRHaeeiY7F+> zit-pHLmk*6t2O%4NW6rXmjTvLABVBa=m0COzkYJZ znYq|t6R{$ifGj6fHFt|FOv4nSu;?kU&=FwV+;ROyOH(|$QmsSm%iN4rUrjiR*1+-v zXUF()eVs|}IN?D}9!g=1@eTn<(aMY_xUguHH7Ng0eK$V9D1ybw2f7X;OMWwhv*k(y z2ZOO`ZH(Vc&YhZb%bh=5%r1CV&87fJYZl4UP&*t-8P}}B4b|*%+M%V`>_g3F(*cjP zjM^ndYkqbnE625M&atCTnQ~YKBHi2=@tb1e6&tZN3m}lxI+NQx@AP6VMq`yX3K^Ll z%-C%OmgG)!fOuC9njAY^cWhTWnP7ZDynrqpjoc0wD0Z@I&xaTX7eW$f$9ZHd7YOC% zb7!c#|Fmf8 z;D?X-$#h61x2>cE@dQSNSHL9gc#Lt~+7?inlgM0(s8UnqLwY5wRa_$X5BlDyIw!2o zndY_y0o}){AxqxP$ED7_AWSNQS?=z_Em&MDf1z}PT(FVU$OZFAX|kDa$&W@uV?6hg zyT4F?xB`Enf;>)x$L=o-p}n!su+Lm<4|1~IM6?L;BfLmoP5`2Y3gbj1a(HO}8leU^ zC;Q8Fu%C_f$5X=rCxE+CqEL|nM)sSs=h2oy933XrxkiArC|#$*ET`{_!IKG~48i&i_ zn9nFKAE=|U13jT>K;^xD!pAY$;hd_hIz^a0KO(X(QLLh!;KhW<4Yjc8|4fLiQ}bw~}akX&6JXjKS?Js#&2WDXJNfxfazt(dQQJJq;sCGE_85B{}>LmA&IdeUHWQ z2G2q3+MvN$_qj@lovG!wK|f3ik~AZ^jWL}RR72%nvf5@8ks*X%#lid!YrKXaLz5fF z@*DaZK0J~1&-&qsc&=^9B$v6GbV61%9X?vJTnw-^wHMAO;*31|tQg2#l`5V?2C8Ch z&oS6=%)sP3%P=JQp>Nl}Y9ekbP=-T}C-qZvk@=7tl*VXN;#dR3#q29N_%YrfJPycO zqPi9;umbCw4Z8f{0EsD!bz6^30^#Q?okU2w^9wv&A&>%g*pLZh&U*k4S5yQxr1N)) z4dITcv7xK?Sjg0iRuW9Ta;$@m$<$k=h7{OFj#hj_-~4)_#;~r$)H{;V_A7Do>qnYq zTe!;An_st;ujjai>pN#VidpE!9Q0R^ z3D}K#A%Wb)(1r0bi#X$+{OBWM3&aO}qJ`g|vf1*l^bH=NK*jQOjkkXtE>(NJmbUWi zDvZX24(5&vf@4D%MRIb>u^(W$ygV9Pyef|x*`wm>UXdA4FsQ{><VyUv($MDIjb5>#tCas`y22`&T)s$ zIEVFJ@qmPeed_`kFA_PE4$_D| zENBFTQ1YbN;I355{N$_^p19=ENt#Lw1i-xF@nkc!N>kB039{mx+#DS|^v4lK$7)dz zJ{kV{I1^^F$GjXMA#d(p zMiFy`t5ZbQ&2E`;4-yo*nNh~)#b*B|xALg}_}U3!dba#_IH_6$4k0SXMx@q=^OKSc zrR}3>`OSSv)xn*9fMpg8v2%(#B*lczvFzr?Y1?poDWNQ_JL}@ohC_*ymbP%H`qCQnNh`~eYGqmAp_P?9QD514-3v6k zKvX7+EHmK9%39$ITv?m3qE*N5*W&?hi5Nx!PKq>*v>kkI0f}0r9r{X0_vKt!(zq;( zMQw>M*_99VY6<~zDrbt)<-XD@v?ktMy%MXJM=hKdsCysN|2!<&5@ESsrmCXjl0 zuCdu0B97VanNYNL=-`W;>mTl4!LrGMtL^?fz$1pTo9b-$pp#>W?9b4;8O+PhaAH2I z4tL5gn$j{Ra!}c-y8t;JNK~Ma_*p%w%`;<4DJwhZVdZnr$qK$Dg@-^){?2nQSnO%P zX)gh?u}SbH?%3Ml>|l?2uv3T{VReBPa|*{03A~lOfMr5LL?d)hXS{ZXfCb&MW%nkD zUn38&Gx*s_?IzpdMHy$9Er}{a-!3u1cOtByycW&*&ZuTYc+-1kjy?hn5}!RjJh?)Q zbjD2U9L37|0aTq-tgUq;aBO6~xu+zpcU)*+_6lM{#|h28)p7{lsOa`F8>UC$2v+&*Z86WXGZVV!W1z-MGPS}@?`-TN~?&VU9ZK^l1T_Z;! zwOInD`U%Bw?bxIfieky()LWHhZi!>!|4U1B!^KS`Vl?(E9*cKFwi_932yotJxF*72 z`_R8J=MY)&d1JbB#(%4g)b(pj(wQm~2oUL#IAToLQq6f2w)-<8vf@oRKZwv1M(XQk zt3_D6-huu4g^YUFTqN?8fI8L#8+kY^_|BPLycjE~n>#mfcqeT)6YXC){fQZJJj3)$ z?J<4HEtj)@Epd9Mw#m%Z@9VqF>78+X*3XV;myyW>SkItCG8*&0;=6ss__|N#GA1tz zD%LUv_~$A6doCrBFy)&%+qh&wa*m}D;svEO*ZB|&E*QNZi!o{?>(0|TlhLcH(O@Nt zB_$|yDRx@F)kY4~NhfN?0S5J=!Hy*hI(*X1%+KI-$imUD%@DrC3|)g6m!59H6krX~ zrt8`2;A99=!%9aABa?fi;X!4m)2=Y@tPf^aux^}Q*~$m@YNeKxWMS7gZSu^Sn{<}N z&#ou{y@-qk76|Hdxakq$AOWC}oi(GctOjtE5IHUxOd|QFEU!DD?4Zg9qCH*c9y>MW zq^U7OO>Lo?8pGip0S>{0sfni2)FvK+nbl=an`p(3zzB-qU-FBNz1V4IFA#9-#sCSQ>6rNsAQI;58Z4!w98QDaQf2SX4+&yl}Z zAbZXrXJQkDIauxY8FTP?Lf(6p<7r{z6eYCHlWINSl4FnS>ELg<}`%D#O;B)tt z@R7TKR9jl6JYb?z-?h+YfQoJw+J`~uQ$Sf{s!&kd=Q55r^l4&I37fQF?CLgJ%>WO+ zEmy$;xZPpEZk6-1e{xUpKrwZsm_0I>y0s%)wbCt^A}qiFvuVz-={Kj=dW@ef$3uW? zHxe{yJ;D+hBr9fk*Cqe$C-;1*{iZ!L4=|B9$w}w(Ca?oZ6Io*|wdcj@CL@dO#?r(! zU1JMzx@bE`ifPUH$Y6G4x`5m!j)H3FAVY~}-)HJVx-|8PoM8$igp#HgTAE@QE5MKP zf~ZrgC^YQTVmujFw0s?aj;*!UqyJ(KB7Jmi`9%;!`m;5`q6H?54eCOgxSDG~{1<7R zErUNqZ(Y3tt|4el;5R}XNFNR?nEma)0`8MhVd+$7b2sd}zr5Bm&TDUH^n4WMh?4h&PIZ$Ou_dUa%+qSdGW@>Kuk+ zcg}KxeA3qiOA;WB#&|Q`uVs;u9ltOa4M`e|d3|z}7;`*Oxfa^lH|=E8kR5zBWN1`) zCu--2c5)@*o%Os6apn$(H28Frl+6-Ch~b^w9z2-QR5J`lPgq2J{nms{K|h(tna1|n z)K378U!}VsbvjG}K_zJ_Be9+m=P?btrXrms7}HS?Lvn4jmnGJZgXmH|k@O|QB<*E0 z0xZMWTxl=zCPB|NTE^M2v<6!t~1hT zfk_}}fy6;st2CMofq=OS1VBO{kbYtc+-C0(pHf}RNg$Xg%b1q4nO4jgZ!2Iqlxzh| z^U(@iR`Xd)=8(5{-1qwoF6=-W3>yPUUS zZozk}nH#K}hsrM|*xR&{|6Qd{u^8ISg2J1U-)J9c82+`7Jc09kUM?Z`xMT6x*Il(_gzP1^Gbtt~kpOd% zIX2v26t;Gm@2(`Ppj+v578l-JJ_Tfa=P|1!1jpHgf1?As!m45p{Z>YV$heY=XyTEm zh=(!NyV?C`6B$SJyfU+!#u5ZnhqN$abGtx{L9D#1jCqM=FK^WTA zd=OW-kQ3b!n|uL<+qVa!tRKB*1mZE(n%6xNwkP2)s3)&vpz@6eyCN|7YUDEH9Ix9N z`!7!S#Od1h`?YaTJYARY13w&VNdTYBFwdfbJmyrm>Yixcd3)78A;asXh4~TB%Ztc8 z@glZ4o~bd0uVa4Gqcv_}>Or?SU!w%1yJ;fv|QxeEp zG|rAg5Nt!>L?^#$bBxzwT#3sQG2(wHo8ya93OQF}HeVYlbEo|4*mx#NR!5M!;VVy8Bg`B<@24Yr`@ zr}~~b*$Xk!p^O%F+hELMv4_AZ{u`6|7#%qO`M@JCll)j|Xw0}woD{)P(pvCLV5wc; zwyzS4NxAaZpcRQI+-#szkXHPoR@_U)cCv+jlXD_d+^i`<7}nU~d6qOFtQMBZ6SZ|w z_q^Fz3r1jvV8+#D1ypx4b?2kutBd79Ls3jd1GbmSU@-z+Elh;2{2PS}BLcFGIUVt~ zF~e@iWW3yKSo(x)gZG7w(Am2rnp8m-vHTNZ9o`5!Ks(m1Y76xgsw)K@YV zPl~9Jd7>N46OJ4P-U-TzN6X4+1|ts1#xVYR%DfOAE5i!`J94>54o)tY92{Y2dF67E zVK61xsQDX4*_iCCBH&=pyR;s4iJ>tj4UG|MXer<;cUMT>4EP#1v=cv5x&T6zm%in>Ip<8 zv(Smht0xezor8w)E-=#I|C05Fq77Y)Q)OS^lX9#S}9sfp5gN37Ol<#{JO(`hA+wc^jHKn)se>!GNKUQR_oYyk+p;kl` z9p%fk?=hnD0={VB_C;xl4CS^!GWxzx=V`N|r`y=$8}E;JViiFN5mrxw+Dl-#)v`en zcfe;vSUul$Yv(pv)9^xTQ$;U7VMy8`-PvLXO45q=@>51vVm~%E|IJIgVmgCJayN#m z5!pWVcIKn$t;dD$f4pt?OX)cDOYM%kvUwcEmVH2gWRc}>eh04)K%#tI&?W&tGhTa!<_2wnPN(gx z-OS?)Fc!e)IL<)yJ|BVUu!e;5>mW+Pw(psM%fd8TkC2au9kE!WAA{9mQ(6ANFiKyZ zU;^d|AgO8HwMlajjJ_p;`N1o1Ju;VJyA_M%P=v$}z) zbet}_EQPi`I}g+@$kW9^i#;v!cNAS;n)@9Qz(8n(72eazKk+Uwr|62da z&;RDfo_yrN-+%vetv4I;0Sv^3Kl#){`|+E{r$(E z4Ug2M_BbeRh7YGngpx1(=5M{}_a6Pk2R^TQc_B9OH+G3kmOrGe%~s65dmeuQObL}2{Sqqj+ z6Z}yA4h~>(fJd8zUi>B1tln9~pebAuM>^||w3=Nl<)Bp_f|uFO(*KF}mG||*4fe$X z54z=ngOWplz7{A5TeYpr_Nm&w71(U3-|gSgz}}AIpCPOumIY9@D$M0vn<9ogy7ue8 z2)l*4ojU41)oyoUiVP?s(ryLtUIlQ%;UmED{MG>eu^}MXiBZmwCV;bQ>}gM`n#R*j z;{pD*7j75`75KW!gUq_tXLEO5EM}7nASyZrp7+@>JM;)dk@4UvxnWTU0w36&5S zrtuoz7Kd^H7?N+j@}w57lh_P+%ra6%@NztFH#SbOiIRug`~PJ8+8IEL_CE)CbqJAF zEZh07X`uCmx}vxL!^qp;xSZrwP-Ku-)Z1|Y$9_~zTQ)-cEni8RH#SiAH)$_z%j{cF|OXG}k#`_^m9-v8ZyU%OgiG3$hT zwz<&dXRUq*5tdu^iG>WNU1Sm=fei7wh-p&6|%?u)uBOw}*ze2oJ_bor8 z$N3N1-@iPa? zmxLNk#67crtljRuzFclEX4!77Vg4a?GiV#LLFXEDms+iX4x_g3yQf@!!yAv>e~%PL zO%{N&Hir)0gV>;2K&e*iUsLN~*?F~g10yb?wR9r+OZ3%e7s!+tq+NF5`ub*d=8?Ub za{vA9OisxP;d(U|tKDBB%E1A0hv?PB;BNkV($kBc{9M!8fE*WzmhK|-X1iGzp$Kon zGa1-x%jxgs>&&aR4=8x;KeKUaC)8uLUrfDvJJamuzb=qSaMqsogfD|BK{{5NAo=T3 zxzd=|LA)?%D(w^!7o~0H`G2w&R0!rVB8&<>MPhfgfiO;fgb;2`OeoqbiKh-yGs3-) zq9+A-h7W6J-k%~8u%Ql6m&8>yTl64yTL32YNgDw-|7jUs!4HU&Z@ctOnl&w!umAqA z#8RHE_nCugLgO%7L_B)W^5rKafEs8!w9Rz#&q@dxWQqos&r*sc8*LCg^54qI)j^hE6899xOEEh!P))6CFtT;UUYdUtPhCM_sSc za_vm?ha~v5P;d*9nUT#wg>G zVGl|uE-?;;BOO6oIxWZVF!jY5z$Nrz%)V6(W*@m{F!!3GMcx<}uE@aon(r?%j1aF{ zaKa>5Isd2uP_~ILnJtMM>?1fWy&)M^q}!QH(+8k~Iesk8+nI8HEu=?zc*H3sj^yww zq?MyRAZBglYD>S=hIq_efjy^HgmifeeoSn}R6%fnY)lNwQ~gMeyQk<9BYrTH)d#B8 zmdaThjEy1vX0_FE{2gcH20!sur(7`NRok@=^RIyrOjgA|n*X+7Bpi8hv5?=eVFecQ z5l5#{7V`E^o$ZZbAzkgMaHK0?A;A0V%RdnKSfro=}@jpO*o=PLezLTUWtkodW7FDytkc?WPNKEC38@FWtiVB~^PV3cv#Xzi!(QUIe@(TN`OhN!m8@BJnS44Xk(oX!v&Wuj4N~DTA zaU~8$b9sGhwvCw`xf^!mE>f%Q$cV03ux-mOdNNq}mdq}k!HIfthEk2C^>w4@ZcrFZ z`IZcS>8S}!u*DSH_3Ud9ac0@1XKI@?LeI!1tv;q>AM>;yrFUAi&fFY8svmYd z{aQ(6Xh}2o@aC8P=CA*1`d)-=2Dmt-y~+f9M*1q#HZtrLC{DMuOuJ|SVw%hHPsz5* zW!E*O`KP6(jlqBQ%1j@*Cm{G@uVi+e*ZZn4;)ApwWcvJJQ7v<3?#}&r(z7;*zAY8P~GKioon)0Q^ z9{Fu%*AtpCXt3sy@+GewbR{-6)JXwCrTxDj^g>}-`yL5;)?gg! zH0(Nm(AW;f=BO>YCf>uBIY@d`wp6e}3knz!HCR&n@+JP)M*ao9w92h4ZP8;XTjJG{ zG%SmUhMML)@1vWMp+K4vge`DDLLhxT>7*Sx$!eWsu@kvIAaZxA*vH*9#?${`yXrz9jeSVG#{jVs zOp#gsM)wU{K!N&?F$^qRMj=HYkmeY+FN)YHqZ!iT7nU?ncM<15YYPD@gJh`~-<1&q z2lx^=s#f#Q1W0B1dt@A;uv(e_o>?C3oNj;BCz?tznsFpqWii4T0&b~8Y*ZY!aS*l36*E?IQ;6~H$SZRI~%=2a1(k5b!5eF^p0#zx!Xy?d3R74Ktmu#>*J<*gjl;^V6N~knp%thq^@GF;I3$lYznk&Abmp zD0eNrhrw9h(0zzl3A{yy|MPC9O4(r+fM54B$U2x2Z|h(NIcy0kFc&yecB@;1?`>7L zRCVCiyEP6!q1&YhvDBv^meR6o11~QKR^^)&{**ss`$V@qg2ZN~)9#-3t=WClx~N*Z zFx|Ys(5E44SGh-S$qZTPqFgzp75kvrN2^~xW-Y%Y|3L|4?6h(Szo71l3EeH%yL)ej z-6Ta})%il3e)G3#5bPP5*qQN(UlL01Y3(^i4#?bG*;;di=^#hv9 zdI$9aS{FrIz2V&1rEhQ=*}jE0<%K$qS#(9hv7Pmpg@g`zzd{FaC#}3qk8Z$)S}_Qx zu7whfSyBi}0Q`OTf{9Eqt*1o<2!$PN@V$r`%kN{(Q3QOqq}epsWq4j%XYGh4zqEa0 z0gl3Mp(>|g2c7K$w)x#E^=*=&@Qh*@_-)P^i{25Z5!*XkMpgM!w)I(Kxi>ZgE~v4+ z))*p-u}xu@HFl@)=g3|osK+(<#)4(#bFHvqSqXn(IHbC<4O447wzI1;n zWIM}yD{7DL>wJIO0Q0Ak3}8f=7U(kF=`E8JXzCI@!kYG4k849cJ~7lIdse{z@2jMj z<*ah_W%++L((8z)YGzTkD>_V80s-n#`8-gNFHl?HFB-Hv`4?f{lHFAHr}29hyZd)- zM2^~-z6~AH&YG|)kGN7w(3*wXO$w#{>vI@7-lE%1(%KyO#h3IG}|o~>di(LS^j$} zbfH)kE5J!8uE73()!MFs9Uatwn&t0z5l4*+-^sWq;g?NshZ?u0>~A$cFU#`Z)d;Lg zf_hB~7UfNvNtj1@;pc%uxxIYwF+t-8-bH&fs70+$s4<^M8*FriDJ4M?^ae@l;6kGK z4$G0tc7zeau+@P&zN}K6EllCOHV>#)Gc~;z3e+|lkOS+P+i&$l6%h3q~IJVEQnHe zQ4Fi70C)MfU6O@*;8fYl-)*|N4Yu&7FrRJu2EcB~5OaHy-xo7umu4~b>ExdkwhY=} zmrW0qYd~e`5E(G_Y1b4CEf%}zE!ic5RcpjR2%bV9grCZCDzvMGN zA7F%f>frcqVcY_&HTV7ipH*bORlQSwYyP?L)+x$t8EC!^BSyOnPdeoz@{ajS6a3{R z7O7gM$6QMCaq}FW9=;0#);zQN#V`!wfK$!2$S?XIuBm)z=+#CBi*A>l{EuwFY+hRz z+Zh{IO74$ND1(u9GLs;%{OZ;OZCWv>T%nyXzwm=`RqWZZ&j=E;JiBq^*{2@RGpvaD z7pj*ajv~Xnn15PBS!B^NXlsYr0E%}1!FGlJ)db3I*egHtfL?&BG85ESSH3k|eiK3x zm2m*2kp(re_0&9DiDBh3LR&fyDt-ScA$B zzEM53^XIhoiWm$=TbX9;9aXdVf2ISkA+*0^O>pm)LQ43+a;5n3-p#Fcx%;+-Zr`65 z7IMPY^vZ=`w(Xc%^TXIRgB26p6K}yNmw!b3R;!m=@?o2ti(CpDV45;!i839kqDY{> z4Q9pYB^;Pl$acfFBX5265lF=*wQE0P?ESd2_Yc)@`V{QD<;ar1UC<~67sHJ5IeY0r zqmPy;>3?h+zq*Br%cCCviupsrB2e;A#9er@npI1tTE|tZoOaSKSM|$lc`Nw^qabhJ zI810Ge9!;D1dCRADzWqr)W$D$s~wSD@s`Bcgjd8C^Y<8ifk9xlp@X5f2t?HAVCmn3(v@h0R>N*B7O5LaU zy@tFXDP%^r*;8$i4@2senaoQX8N#3jrEk+mxcQ;Y&l_=G^I=i_c6~yxqqk;@9&hdW zwMROTMpvI~oov_3NB`i*fBv)E<({v8vCS&Eft-#{{fb8YW5VjeocFajO?z{6iUS*` zqg8m=E7+J04X_ID8_Z*832zLh4i)prsQBMxk(n|X6;HT$+ngU?Fejk+L1iiOmZQA-s?uB!0(w1egHY6jSX{&Oro6w8Zv}skY&llQ3dt~t96n4(e1IiN6No-ZGkjT-VdvAYv-JRp?M;5 zSa*D(VJ(AZLI2Dm6nI52-pd1uGgdQe-r5l`1wa0twZF8RAG6WV`xxeHqX}qwYv-Z{ zB-{-x_`BYYTKHj~Ka?C=ju63%ZfXw?0?PNLoPvr1$D<=ySWF)pY!V)Bj`N3F`iF|m z;9)L278Vg}X;?J&&`YejnJxoHXhEK@ z24Ep-afJE1!veGLbu>&NZnK)UA>v?5LPb@sq2l10_#_~s09PUQiZvao2(eW#4zX3< zMC=trXJ)zCo8vD%r@t4#&p$r`8^8m15Ax0S!CXZ^TbN<$p-OECzF6JzsW| z^WO_)n+#F|GJs+7E_FGyXv;xW!NKd}xRI2lH=58s>(GvTMDTsD@2!p+>wt*S!;;TP znx_r%dK`-S`k)@%l0D7R@96|a|M-X2R39|v}Ek=IIMT%R#9 z!RqDz*~BT0nCFZ*&QUD}{ID2Un_Livfm1GEZOz|n!k|BUQbQ~>Sj{BNT`qE3I$)?# zso`euNAo$NDNNkqCNU4pqa(8eoaKXREn5ATYf>Rn&a_KESxw4G!pg&SVFlEQvJU`M zD9Gn+l@!VXW-r1c^q~j;)nLa2YtoQ{VS=FbM+=<}N8pmEv)W0+pc5AMA>nLW#sQ$N zn~EM&fyqGRu~|2bJ;*`C)oAaW7TtsFxSaE!H{PPK7R}uTHz1_ugxX+;7uo}u`6|EA zkux@K)jXQ{j<=>tWcEKz9|aDPePDmj{@5*>>? zdGg16B;^^#Hf>Mpc+4AT+Q4hNM2+U}L%hjJb5`m@=H=n}S{uGSU7oh*r+MCZzdS?9 zR)XY33W!-aVYnn#!soIsi|yW;J;k`n6Ti*s-;$lt)M)cGGYoAk{bws9V zwU;{$Op8{$JmB{9Qg(`{v8C*>cEE0XD<}zSH-o+ztIZ!w7|g+FEaYaZ?#Y7jFxCMH zh#sPIvtYGlX($%*FBw_W#Bub6JGh%`+Dw(Tw)PMz@Q;Z{sa!WKnFgqCd6>#sHOiJT zLft_tR0-=(|6EyqXrR@UwSL;1rp|2iVroc9IOB5K%oLDe<}tq;~D zRk>j6#rmc7g12~iwO$9bT;G#ci+6mr6rvIx5@*y`)JK@vZ28njRpL^`CI=NipI+J_n(Bj z%$3ht;~zHG$%4fC0_jaKIfkOKK5w;L?Vx3`8=~dKQ@Ps?N!$XD>F&c!sliRBOTpjt zg=uk9gL`mQM7XnAJI&PK4#dmHt<$){PK$Y$$5b}4hjOK(#j)iB_a=3?f|=(`hDu`i z!r#Z@DwmI1pHU@&V;H~Ef`|eX;WjP3d(H_(r&WW;l=3w&Lr%_Gnfp)uS;TZTh5OVg z1WKn|MJRbA^uY!-LLM`TJnVQ!gGQ8g%%~m(XDq2K8L1R{dPS6S{48K+8xNFHY=}}& zdyIf8LfIxlxp9nJlr z933WsTj9a-6I&Pv1CiNb`j%`pm>q27)1{dnrX-*d6PsGf?v|;LREGC+ zH%y01UNFdOdj+>_L+!GcW)?k^>2S_;(JG1eym-vkQrb1v3y-U0caBC3-HRZ$fr5=f zr!7-oH)}+;6?1R3wqmYfkbE}iz8S_drENwXcizlil<}~87`1P9KhFsM;HO;Vu$%qj zIgCn&mGH^03kJaAyn^mTKC(|+_xT%Sp;B0&DDF}56=#);TZ+xD@NQ-${o7RGy33lH z+u|exg|~}M{#^WWuqD==3W6r%^`3nuJ{q&!+pNPlT*nR#r8bg+t&s->TayvE_`7O< zfnrdwnG%z;r$NEC5+5l79iTigK#^psk5^MQjcgwf3sV~8`jG>^DVASwxoDN0Eeiy| zymNSPO_A?U?_A4LpnP|<0C{oke!gF8BG#7T8lnCct%HPQus{EZnNAg#X(!t-4!sq? zmy4mJsCMfbD=n2fmVK!pVaQ521}d{iQzcwxK4?1*7dBaj)#YFXs9OxS&^KS|3XfwR ze8XO-6do@};qmgM_<1>tE1^f2YTQ!OLLQP-*H~1o$D<}nTd1kyL0!=EHs+DzwH->> zn<}59RTCek_GGta&uERGSOX}C$69)NLG3Zbvt>v8vto_LG$Uw|&BX>9LS zr$@q6@C-edC!9i+A=a{S?D ze>ybF^u5#a$bZrty;)0Z7zW_RXDe|!^_}20JfIl+%VYLhl(`K#Hff1oSiVGquZ z;4EBp1h^$T5%98n%tjG7QDVBQhL07~MGhRJ0M+{~PejSXcCSgpxLd<8p1WrCk0o4P zu`Vl~`;>kUG2F{f6N()>&8MyP$Z*>Td)z!G2D2qqrISsJ3V1THN_T!SQEL+V)(rb+&s~Qu?bk10kUT(_Wm_RF-5Qe5`38WcH8( z6q@7)tahf$j!@qOp-Df(mjR8vHiR^v~?aj zu~*6qPlGS{kGQ-{8Bd%!4RCL*1xwcX_JBOyr}=dgp14J=4Yt5w0X-pIT6h+~gBN6e zKUS5#{V@?8zleVH><=Z7tX=I+E2DHdT|UvUv^=KS1@?0)=q)S;O#_+d|bbzEawu6;=2T~*vJ!W;*O2(yCd+0nms5-FX>GB-VHmzneKeRTp z<*9mA)<=@=HN|EDD7<+XIGS`zYKHxM-xT&UYL#pDcC>ZTyf2wLy9w6?`SmrNvsNo8 zRXP2 z!i^ZD&7du)h$oqqq`?LO9gA8Stc8SHcIF~Xkiq(sTKd(G8`JX@b9G55!4r_;mh8Oh zTrm2ey<`AAZGBQ+*>z5v!TRyaV6CT58slRws~xP7K1x?dHcv2EKPZdzD$Qebtc=yG z$ymLdW^3&rb(*mn8O={E@HSeG0KVGcVJe5~PVzKS~$^guvW8LS{ZFo zM$5rk9cfv6xGz>k%gdY;wZ%(|%Igjjo<&qrQ@bJx${ftDP0?**5HOwm05u~1*)K#H4||qX4wwEIAbD7Wg<4{%Lpl3a4-MMAU8$8qjJ!5Zl{gmlc^%I#a}fm=miym36qT4= zLL7ghA&x6tnP&dRFhIe`wmgcFY)-ru0{Qz{{X~*ZVTSH7s-pKGuilA5t`iyS=9`z* zG=GCho8io@y6JlGZI74E0JEK-1lkyb4>f`<* z+q3*@zxQnloY7e)ZBongKjcXWz5N*Q%!+V_3E`j0fpeb$R@P>XXzTd|uZMD6w5&ley&M?Xkd|0FPZ)j}>1gHY1J|e~Ez- zqnj3HR>XQAACT^Y!E~pI*ktMijC2a6wD}hph|Vk3S;$~6Fp*hFvS|;Z7Yr1X$qhl* zNI$69`*?TS{z&!U1<6LUiWq2Y6ufk&rfrV?Sv#lp22;sBxPr%fS-4qCYd&jMXaENC zxW>-o+i)7pn)he6d=Qzu@pkz%d$T1ouv@w>m~Y8q1q?Xr{FXTT1fS(&zXnpG)u;~b z?q-v;uO<6C;Yg~oYFflv3cr}u?rp_EKAK%31t5Q35q2ei_N0lj@|O)nY)`ABV6-F? zot(sp_$)S5eHBU^XSyI?BQL7Ap5*1Ib>>SNGRtZ+v$#7a$P^(nI$VvJsLI{B$?xV2aZ;X0x{ zUrcYETyqkd!2?b2$gc}NwGL?D@PHuR{i%5zAM!((TM9Ij<#8G`lTC5K`!K4}aF1DQ zCV65Fh|nGc1MP<3{cx>`o&ybd5BkpktO}%5XL&h>9WM_9kgpZ!%9#af3j(Zjy)j`A`8hN(J*hRP zCwRx^!joo$t1^s_L#H1%OVKiY}M~oVRj6m5~+ef{}NnOaxWW8y1u^9@qT7YBLLA340L+Vb1@j!d@vpVHO zKkKYyn5Tui6Q@6EFgqs<=95MV(b6*pGd1FXOv2gm$fPGtWHMK)X3X5fyb1Qo-xK)I za^$;3KmUnPMoo}Hm7D0Sa-$8E*ZNnv(T2*Ky{|iMXgc&%(S}Gu1*sKLf(n|io4-|q zUrobwO!n}2?b-e?IPcr|2{aPy`IHx-IS>8qXV|uI(aLkiC%NTB?-#QmYZ<-<#4pdM zQk9IO0ljUJAM{92AF{e+S#NXQX3FUg=N2{Yq9?4OCaaZ7vv+)iA;fiWf?>mJsCj)A zmr*m)BBdF{RZA0z3*8+5WtY*giZxEl2!0^h(Os1F!WvRi+c{0nqT>B5#gfI~l+PL& z{aZVRV@HGH7D^m*lz+8__6WMGZK2YWYzqy}-uf158#I!a;wqkRHlL>*+M9=!O3fJ4 zLEAgX3lsjO@XUtL9G8}vg<`5zOoZKzW&YQy9YObLC8qQyah@B)XhP|~-^wBSUKLZk z+#8Zxk0T38Ze7tQg6o6&L~?z&;RbN&b&Ldyg(XO^rcTx*SpSXBF6f~~Rn%opXF7)L zXU#eTMf8Fe$|FQTBw4HLRF7WOkZK`98d0Lq^cK}AjZ9*Vl~E_>F*ux-Bzw-@P>IA| zY8RbeGSQ?C(9$3v=HW11y(S8Lczmy%zl5nr5PYMjY z3+6e{1;(2?Cv9FY^TI8I7>)0maNd0KC7=4i*+iSOv?x;=G^ zsxnUFpfG-xETCFrE77_^xH1PkLl7X;U0$%4odFpy;QSR4_Bwwx#bbMIFzx5BP-}?| zH2E5vkEg1JDqMz#(GH`32-07K?J5?Dd2-VK_ci_0AD7?g+@bY{LhQ4T{mrRA{+K+E z#H!0#%&cJn!`eKcYCf0>kbM;r^5*Ycm<{`;1xtEyw z&0)BCvH4X9v>c9BuTop(459CHZH~KfrtPF;Tn}*96oC5tKFrN?dlm8sicuTo93_c& zPPf&OS_sS4&riE(elo?3iepI*^6pRym*J>jDAJx%zW4-)^f$~?J;auGaNg1-n zXpq@#`4Eut9@PbA`_zS?qAqY2I}6l|Z^^_m1&i{$bug@8IENVC%bkvgOIHjtVre|G zu-Yh%ip!}+X}ryW2F4UHeHsVD_E6hGWe^SGVI+sW4Qg2V1JEmXYA~i@m@|eN6pzKWYmdhe z!)~)~nHgyeDeN*Xv6FDw$%MdWqP3J&#kN0$rv@RcYNQn*pxW84d1*qxf;&V9OQM6D zN9jORAe*yL?2M-BVpIi9h1|%LFI5Nj=#nIZRLOF$CPluLah8kavOzXr(_7nhOE>

{=wt*dv=}mLCaKe2cW_WX+Ms#kOTc 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 z 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 qXC+=TcNJsGG?g=Eh{b}7L5> { + console.log('Start sandbox...'); + sandbox = exec('npm run sandbox:test'); + await sleep(5000); +}; + +const mochaGlobalTeardown = async () => { + if (sandbox.exitCode === 1) { + console.log('Error: Sandbox server failure. Probably, it failed to start.'); + } + console.log('Stop sandbox...'); + kill(sandbox.pid); +}; + +module.exports = { mochaGlobalSetup, mochaGlobalTeardown }; \ No newline at end of file diff --git a/tests/test_token.wasm b/tests/test_token.wasm new file mode 100755 index 0000000000000000000000000000000000000000..8f15ee19b988bf9a13500e8bbdb1b35d914ccb5e GIT binary patch literal 178021 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 literal 0 HcmV?d00001 diff --git a/tests/tests.js b/tests/tests.js new file mode 100644 index 0000000..251f849 --- /dev/null +++ b/tests/tests.js @@ -0,0 +1,733 @@ +'use strict'; + +const assert = require('assert').strict; +const config = require('./sandbox-setup').config; +const BN = require('bn.js'); + +const ONE_NEAR = '1000000000000000000000000'; +const ONE_YOCTO = '1'; +const HUNDRED_NEARS = '100000000000000000000000000'; +const GAS_FOR_CALL = '200000000000000'; // 200 TGas + +describe('Smoke Test', function () { + it('should get a version', async () => { + const version = await global.aliceContract.version(); + assert.match(version, /1\..\../); + }); +}); + +describe('Anyone', function () { + it('should get a name', async () => { + const name = await global.aliceContract.name(); + assert.equal(name, 'USN'); + }); + + it('should get a symbol', async () => { + const symbol = await global.aliceContract.symbol(); + assert.equal(symbol, 'USN'); + }); + + it('should get decimals', async () => { + const decimals = await global.aliceContract.decimals(); + assert.equal(decimals, 18); + }); + + it('should get a spread', async () => { + const spread = await global.aliceContract.spread(); + assert.equal(spread, '5000'); + }); + + it('should get contract status', async () => { + const status = await global.aliceContract.contract_status(); + assert.equal(status, 'Working'); + }); + + it('should get an owner', async () => { + const owner = await global.aliceContract.owner(); + assert.equal(owner, config.usnId); + }); + + it('should get a fake storage balance', async () => { + const storage_balance = await global.aliceContract.storage_balance_of({ + account_id: 'fake.near', + }); + assert.deepEqual(storage_balance, { + total: '1250000000000000000000', + available: '0', + }); + }); + + it('should get a commission', async () => { + const commission = await global.aliceContract.commission(); + assert.deepEqual(commission, { + near: '0', + usn: '0', + }); + }); + + it('should get a treasury', async () => { + const treasury = await global.aliceContract.treasury(); + assert.deepEqual(treasury, { + reserve: {}, + cache: { + items: [], + }, + }); + }); +}); + +describe('Owner', function () { + this.timeout(5000); + + it('should be able to assign guardians', async () => { + await assert.doesNotReject(async () => { + await global.usnContract.extend_guardians({ + args: { guardians: [config.aliceId] }, + }); + }); + }); + + it('should get guardians', async () => { + const guardians = await global.aliceContract.guardians(); + assert.deepEqual(guardians, [config.aliceId]); + }); + + it('should be able to remove guardians', async () => { + await assert.doesNotReject(async () => { + await global.usnContract.extend_guardians({ + args: { guardians: [config.aliceId] }, + }); + await global.usnContract.remove_guardians({ + args: { guardians: [config.aliceId] }, + }); + }); + }); +}); + +describe('Owner', function () { + this.timeout(5000); + + before(async () => { + await global.usnContract.set_owner({ + args: { owner_id: config.aliceId }, + }); + assert.equal(await global.usnContract.owner(), config.aliceId); + }); + + it('can change ownership', async () => { + await assert.rejects(async () => { + await global.usnContract.set_owner({ args: { owner_id: config.usnId } }); + }); + }); + + after(async () => { + await global.aliceContract.set_owner({ + args: { owner_id: config.usnId }, + }); + assert.equal(await global.aliceContract.owner(), config.usnId); + }); +}); + +describe('Guardian', function () { + this.timeout(5000); + + before(async () => { + await global.usnContract.extend_guardians({ + args: { guardians: [config.aliceId] }, + }); + }); + + it('should be able to pause the contract', async () => { + assert.doesNotReject(async () => { + await global.aliceContract.pause({ args: {} }); + assert.equal(await global.aliceContract.contract_status(), 'Paused'); + }); + + await assert.rejects(async () => { + await global.aliceContract.ft_transfer({ + args: { receiver_id: 'any', amount: '1' }, + }); + }); + }); + + after(async () => { + await global.usnContract.remove_guardians({ + args: { guardians: [config.aliceId] }, + }); + }); +}); + +describe('User', async function () { + this.timeout(15000); + + it('should NOT sell before buying', async () => { + await assert.rejects(async () => { + await global.aliceContract.sell({ args: { amount: 1 } }); + }); + }); + + it('should buy USN to get registered', async () => { + const amount = await global.aliceContract.buy({ + args: {}, + amount: ONE_NEAR, + gas: GAS_FOR_CALL, + }); + assert.equal(amount, '11088180500000000000'); // no storage fee + + const expected_amount = await global.aliceContract.ft_balance_of({ + account_id: config.aliceId, + }); + assert.equal(amount, expected_amount); + }); + + it('can buy USN with the expected rate', async () => { + const amount = await global.aliceContract.buy({ + args: { + expected: { multiplier: '111439', slippage: '10', decimals: 28 }, + }, + amount: ONE_NEAR, + gas: GAS_FOR_CALL, + }); + assert.equal(amount, '11088180500000000000'); + }); + + it('should NOT register the recipient having not enough money to buy USN', async () => { + await assert.rejects( + async () => { + await global.aliceContract.buy({ + args: { + expected: { multiplier: '111439', slippage: '10', decimals: 28 }, + to: config.bobId, + }, + amount: ONE_YOCTO, // very small attached deposit + gas: GAS_FOR_CALL, + }); + }, + (err) => { + assert.match(err.message, /attached deposit exchanges to 0 tokens/); + return true; + } + ); + }); + + it('can buy USN for unregistered user (the recipient gets auto-registered)', async () => { + const amount = await global.aliceContract.buy({ + args: { + to: config.bobId, + }, + amount: ONE_NEAR, + gas: GAS_FOR_CALL, + }); + assert.equal(amount, '11088180500000000000'); // no storage fee + + const expected_amount = await global.bobContract.ft_balance_of({ + account_id: config.bobId, + }); + assert.equal(amount, expected_amount); + }); + + it('can NOT buy with slippage control in place', async () => { + await assert.rejects( + async () => { + await global.aliceContract.buy({ + args: { + expected: { multiplier: '111428', slippage: '10', decimals: 28 }, + }, + amount: ONE_NEAR, + gas: GAS_FOR_CALL, + }); + }, + (err) => { + assert.match(err.message, /Slippage error/); + return true; + } + ); + }); + + it('sells USN with the current exchange rate', async () => { + const near = await global.aliceContract.sell({ + args: { + amount: '11032461000000000000', + }, + amount: ONE_YOCTO, + gas: GAS_FOR_CALL, + }); + assert.equal(near, '985050000000000000000000'); // 0.98 NEAR + }); + + it('sells USN with slippage control', async () => { + const near = await global.bobContract.sell({ + args: { + amount: '11032461000000000000', + }, + amount: ONE_YOCTO, + gas: GAS_FOR_CALL, + }); + assert.equal(near, '985050000000000000000000'); // 0.97 NEAR + }); + + it('spends gas and gets the rest back in case of error', async () => { + const balance = (await global.aliceContract.account.getAccountBalance()) + .available; + await assert.rejects(async () => { + await global.aliceContract.buy({ + args: { + expected: { multiplier: '111428', slippage: '10', decimals: 28 }, + }, + amount: ONE_NEAR, + gas: GAS_FOR_CALL, + }); + }); + const balance2 = (await global.aliceContract.account.getAccountBalance()) + .available; + assert.equal(balance.length, balance2.length); + // 9.99 NEAR -> 9.97 NEAR + // 5.71 NEAR -> 5.68 NEAR + const near_before = parseInt(balance.substring(0, 3)); + const near_after = parseInt(balance2.substring(0, 3)); + // Should be less than 3-4, but it's 6 (0.06, ~$0.6) because of the sandbox issue. + assert(near_before - near_after < 6); + }); + + it('should sell all USN to get unregistered', async () => { + await global.aliceContract.sell({ + args: { + amount: await global.aliceContract.ft_balance_of({ + account_id: config.aliceId, + }), + }, + amount: ONE_YOCTO, + gas: GAS_FOR_CALL, + }); + + assert.equal( + await global.aliceContract.ft_balance_of({ + account_id: config.aliceId, + }), + '0' + ); + + await assert.rejects( + async () => { + await global.aliceContract.ft_transfer({ + args: { receiver_id: 'any', amount: '1' }, + amount: ONE_YOCTO, + }); + }, + (err) => { + assert.match(err.message, /The account doesn't have enough balance/); + return true; + } + ); + + await global.bobContract.sell({ + args: { + amount: await global.bobContract.ft_balance_of({ + account_id: config.bobId, + }), + }, + amount: ONE_YOCTO, + gas: GAS_FOR_CALL, + }); + }); + + after(async () => { + const aliceBalance = await global.aliceContract.ft_balance_of({ + account_id: config.aliceId, + }); + + const bobBalance = await global.bobContract.ft_balance_of({ + account_id: config.bobId, + }); + + // Flush balances and force registration removal. + + if (aliceBalance != '0') { + await global.aliceContract.ft_transfer({ + args: { + receiver_id: 'any', + amount: aliceBalance, + }, + amount: ONE_YOCTO, + }); + } + + if (bobBalance != '0') { + await global.bobContract.ft_transfer({ + args: { + receiver_id: 'any', + amount: bobBalance, + }, + amount: ONE_YOCTO, + }); + } + }); +}); + +describe('Adaptive Spread', async function () { + this.timeout(15000); + + it('should be used to buy USN', async () => { + const amount = await global.aliceContract.buy({ + args: {}, + amount: HUNDRED_NEARS, + gas: GAS_FOR_CALL, + }); + assert.equal(amount, '1108854824870000000000'); // ~$1108 + + const expected_amount = await global.aliceContract.ft_balance_of({ + account_id: config.aliceId, + }); + assert.equal(amount, expected_amount); + }); + + it('should be used to sell USN', async () => { + const near = await global.aliceContract.sell({ + args: { + amount: '1108854824870000000000', + }, + amount: ONE_YOCTO, + gas: GAS_FOR_CALL, + }); + assert.equal(near, '99009067108900000000000000'); // 0.99 NEAR + }); + + it('should be configurable', async () => { + await global.usnContract.set_adaptive_spread({ + args: { params: { min: 0.002, max: 0.006, scaler: 0.0001 } }, + }); + + const amount = await global.aliceContract.buy({ + args: {}, + amount: ONE_NEAR, + gas: GAS_FOR_CALL, + }); + assert.equal(amount, '11077081175600000000'); // ~$11.08 + }); + + it('should be in limits', async () => { + // min <= max + await assert.rejects(async () => { + await global.usnContract.set_adaptive_spread({ + args: { params: { min: 0.006, max: 0.002, scaler: 0.0001 } }, + }); + }); + + // min < 0.05 + await assert.rejects(async () => { + await global.usnContract.set_adaptive_spread({ + args: { params: { min: 0.06, max: 0.01, scaler: 0.0001 } }, + }); + }); + + // max < 0.05 + await assert.rejects(async () => { + await global.usnContract.set_adaptive_spread({ + args: { params: { min: 0.01, max: 0.06, scaler: 0.0001 } }, + }); + }); + + // scaler < 0.4 + await assert.rejects(async () => { + await global.usnContract.set_adaptive_spread({ + args: { params: { min: 0.01, max: 0.03, scaler: 0.5 } }, + }); + }); + + // only positive + await assert.rejects(async () => { + await global.usnContract.set_adaptive_spread({ + args: { params: { min: 0.001, max: 0.003, scaler: -0.4 } }, + }); + }); + }); +}); + +describe('Fixed Spread', async function () { + this.timeout(15000); + + before(async () => { + await global.usnContract.set_fixed_spread({ args: { spread: '10000' } }); // 1% + }); + + it('should be used to buy USN', async () => { + const amount = await global.aliceContract.buy({ + args: {}, + amount: HUNDRED_NEARS, + gas: GAS_FOR_CALL, + }); + assert.equal(amount, '1103246100000000000000'); // ~$1103 + }); + + it('should be used to sell USN', async () => { + const near = await global.aliceContract.sell({ + args: { + amount: '1103246100000000000000', + }, + amount: ONE_YOCTO, + gas: GAS_FOR_CALL, + }); + assert.equal(near, '98010000000000000000000000'); // 98.01 NEAR + }); + + after(async () => { + await global.usnContract.set_adaptive_spread({ args: {} }); + }); +}); + +describe('Stable Pool (USDT/USN) [pool_id: 0]', async function () { + this.timeout(17000); + + const MAX_TRANSFER_COST = '780000000000000000001'; + + var dao; + + before(async () => { + await global.usnContract.set_owner({ + args: { owner_id: config.aliceId }, + }); + dao = global.aliceContract; + }); + + beforeEach(async () => { + await global.usdtContract.burn({ + args: { + account_id: config.usnId, + amount: await global.usdtContract.ft_balance_of({ + account_id: config.usnId, + }), + }, + }); + }); + + it('should finalize depositing after failure', async () => { + await global.usdtContract.ft_transfer({ + args: { receiver_id: config.usnId, amount: '1000000000000' }, + amount: '1', + }); + + // Should fail at the `add_stable_liquidity` cross-contract call. + // But deposit already belongs to the ref.finance account. + await assert.rejects( + async () => { + await dao.transfer_stable_liquidity({ + args: { pool_id: 0, whole_amount: '1000000' }, + amount: '2', + gas: GAS_FOR_CALL, + }); + }, + (err) => { + assert.match( + err.message, + /ERR_STORAGE_DEPOSIT need 780000000000000000000/ + ); + return true; + } + ); + + const refUsdt = await global.usdtContract.ft_balance_of({ + account_id: config.refId, + }); + const refUsn = await global.usnContract.ft_balance_of({ + account_id: config.refId, + }); + + await assert.notEqual(refUsdt, '0'); + await assert.notEqual(refUsn, '0'); + await assert.equal( + await global.usdtContract.ft_balance_of({ account_id: config.usnId }), + '0' + ); + + const poolInfo = await global.refContract.get_stable_pool({ pool_id: 0 }); + + await assert.doesNotReject(async () => { + const shares = await dao.transfer_stable_liquidity({ + args: { pool_id: 0, whole_amount: '1000000' }, + amount: MAX_TRANSFER_COST, + gas: GAS_FOR_CALL, + }); + + assert.equal(shares, '2000000000000000000000000'); + }); + + const refUsdt2 = await global.usdtContract.ft_balance_of({ + account_id: config.refId, + }); + const refUsn2 = await global.usnContract.ft_balance_of({ + account_id: config.refId, + }); + + // The second call of transfer_stable_liquidity should not mint additional money. + await assert.equal(refUsdt, refUsdt2); + await assert.equal(refUsn, refUsn2); + + const poolInfo2 = await global.refContract.get_stable_pool({ pool_id: 0 }); + assert.notDeepEqual(poolInfo.amounts, poolInfo2.amounts); + + // Pool must grow exactly on $1000000. + assert( + new BN('1000000000000', 10).eq( + new BN(poolInfo2.amounts[1], 10).sub(new BN(poolInfo.amounts[1], 10)) + ) + ); + }); + + it('should fail having not enough USDT', async () => { + // Should fail after the 1st ft_transfer_call. + await assert.rejects( + async () => { + await dao.transfer_stable_liquidity({ + args: { pool_id: 0, whole_amount: '1000000' }, // $1 mln. + amount: MAX_TRANSFER_COST, + gas: GAS_FOR_CALL, + }); + }, + (err) => { + assert.match(err.message, /Not enough usdt.test.near/); + return true; + } + ); + }); + + it('should fail having not enough attached NEAR', async () => { + await assert.rejects( + async () => { + await dao.transfer_stable_liquidity({ + args: { pool_id: 0, whole_amount: '1000000' }, + amount: '1', + gas: GAS_FOR_CALL, + }); + }, + (err) => { + assert.match( + err.message, + /Requires attached deposit more than 1 yoctoNEAR/ + ); + return true; + } + ); + }); + + after(async () => { + await dao.set_owner({ + args: { owner_id: config.usnId }, + }); + }); +}); + +describe('Stable Pool (USDT/USN) [pool_id: 1]', async function () { + this.timeout(20000); + + const MAX_TRANSFER_COST = '780000000000000000001'; + + var dao; + + before(async () => { + // Set up "DAO" account. + await global.usnContract.set_owner({ + args: { owner_id: config.aliceId }, + }); + dao = global.aliceContract; + + // Fill up USN account with the USDT token: $1000000. + await global.usdtContract.ft_transfer({ + args: { receiver_id: config.usnId, amount: '1000000000000' }, + amount: '1', + }); + + // Register Bob in the USDT contract. + // Otherwise, ref.finance won't finish a swap. + await usdtContract.mint({ + args: { account_id: config.bobId, amount: '0' }, + }); + + // Add stable liquidity to the stable pool. + await dao.transfer_stable_liquidity({ + args: { pool_id: 1, whole_amount: '1000000' }, + amount: MAX_TRANSFER_COST, + gas: GAS_FOR_CALL, + }); + }); + + it('should be balanced when USDT < USN', async () => { + // Bob buys USN. + const amount = await global.bobContract.buy({ + args: {}, + amount: ONE_NEAR, + gas: GAS_FOR_CALL, + }); + + // Bob swaps USN to USDT: BOB -> USN -> REF + ACTION. + await global.bobContract.ft_transfer_call({ + args: { + receiver_id: config.refId, + amount: amount, + msg: '{"actions": [{"pool_id": 1, "token_in": "usn.test.near", "token_out": "usdt.test.near", "min_amount_out": "1"}]}', + }, + amount: ONE_YOCTO, + gas: GAS_FOR_CALL, + }); + + // Now, Bob has some USDT. + assert.notEqual( + '0', + await global.usdtContract.ft_balance_of({ account_id: config.bobId }) + ); + + // And the pool is unbalanced. + const poolInfo = await global.refContract.get_stable_pool({ pool_id: 1 }); + assert( + new BN(poolInfo.amounts[1] + '000000000000', 10).lt( + new BN(poolInfo.amounts[0], 10) + ) + ); + + // Balancing the pool now. + await dao.balance_stable_pool({ + args: { pool_id: 1 }, + amount: ONE_YOCTO, + gas: GAS_FOR_CALL, + }); + + const poolInfo2 = await global.refContract.get_stable_pool({ pool_id: 1 }); + assert.equal(poolInfo2.amounts[1] + '000000000000', poolInfo2.amounts[0]); + }); + + it('should be balanced when USDT > USN', async () => { + // Bob buys USDT. + await global.usdtContract.ft_transfer({ + args: { receiver_id: config.bobId, amount: '1000000000' }, + amount: '1', + }); + + // Bob swaps USDT to USN: BOB -> USDT -> REF + ACTION. + await global.bobUsdt.ft_transfer_call({ + args: { + receiver_id: config.refId, + amount: '1000000000', + msg: '{"actions": [{"pool_id": 1, "token_in": "usdt.test.near", "token_out": "usn.test.near", "min_amount_out": "1"}]}', + }, + amount: ONE_YOCTO, + gas: GAS_FOR_CALL, + }); + + // The pool is unbalanced. + const poolInfo = await global.refContract.get_stable_pool({ pool_id: 1 }); + assert( + new BN(poolInfo.amounts[1] + '000000000000', 10).gt( + new BN(poolInfo.c_amounts[0], 10) + ) + ); + + // Balancing the pool now. + await dao.balance_stable_pool({ + args: { pool_id: 1 }, + amount: ONE_YOCTO, + gas: GAS_FOR_CALL, + }); + + const poolInfo2 = await global.refContract.get_stable_pool({ pool_id: 1 }); + assert.equal(poolInfo2.amounts[1] + '000000000000', poolInfo2.amounts[0]); + }); +});