From 6f56d5760091aed0facf1a935a9de46b888f38a4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=CE=9ETH=CE=9E=D0=AFSPH=CE=9E=D0=AF=CE=9E?= Date: Thu, 3 Dec 2015 21:42:43 +0000 Subject: [PATCH] Swarm - plan bee for content storage and distribution on web3 --- accounts/account_manager.go | 10 + cmd/geth/js.go | 5 +- cmd/geth/js_bzz_test.go | 83 ++ cmd/geth/js_test.go | 18 +- cmd/geth/main.go | 88 +-- cmd/utils/customflags.go | 4 +- cmd/utils/customflags_test.go | 2 +- cmd/utils/flags.go | 111 ++- common/bytes.go | 19 +- common/chequebook/cheque.go | 660 ++++++++++++++++ common/chequebook/cheque_test.go | 498 ++++++++++++ common/chequebook/chequebook.sol | 49 ++ common/chequebook/contract.go | 63 ++ common/kademlia/address.go | 157 ++++ common/kademlia/address_test.go | 80 ++ common/kademlia/kaddb.go | 360 +++++++++ common/kademlia/kademlia.go | 457 +++++++++++ common/kademlia/kademlia_test.go | 389 +++++++++ common/registrar/ethreg/ethreg.go | 22 +- common/swap/swap.go | 238 ++++++ common/swap/swap_test.go | 178 +++++ common/types.go | 13 + core/genesis.go | 5 + rpc/api/bzz.go | 278 +++++++ rpc/api/bzz_args.go | 322 ++++++++ rpc/api/bzz_js.go | 95 +++ rpc/api/utils.go | 27 +- rpc/shared/utils.go | 3 +- swarm/api/api.go | 456 +++++++++++ swarm/api/api_test.go | 205 +++++ swarm/api/config.go | 105 +++ swarm/api/config_test.go | 107 +++ swarm/api/ethereum.go | 320 ++++++++ swarm/api/http.go | 247 ++++++ swarm/api/manifest.go | 310 ++++++++ swarm/api/manifest_test.go | 61 ++ swarm/api/roundtripper.go | 22 + swarm/api/roundtripper_test.go | 50 ++ swarm/cmd/bzzhash/bzzhash.go | 38 + swarm/cmd/bzzup.sh | 46 ++ swarm/examples/album/add.png | Bin 0 -> 129 bytes swarm/examples/album/back.png | Bin 0 -> 388 bytes swarm/examples/album/cut-left.png | Bin 0 -> 221 bytes swarm/examples/album/cut-mov.png | Bin 0 -> 197 bytes swarm/examples/album/cut-right.png | Bin 0 -> 193 bytes swarm/examples/album/cut-top.png | Bin 0 -> 205 bytes swarm/examples/album/data.json | 1 + swarm/examples/album/delete.png | Bin 0 -> 552 bytes swarm/examples/album/down.png | Bin 0 -> 403 bytes swarm/examples/album/download.png | Bin 0 -> 422 bytes swarm/examples/album/eye.png | Bin 0 -> 525 bytes swarm/examples/album/imgs/apron.jpg | Bin 0 -> 419037 bytes swarm/examples/album/imgs/bekas1.jpg | Bin 0 -> 554726 bytes swarm/examples/album/imgs/bekas2.jpg | Bin 0 -> 508279 bytes swarm/examples/album/imgs/bekas_blanik.jpg | Bin 0 -> 604048 bytes swarm/examples/album/imgs/hangar.jpg | Bin 0 -> 435136 bytes swarm/examples/album/imgs/hangar_inside.jpg | Bin 0 -> 646483 bytes swarm/examples/album/imgs/ruin.jpg | Bin 0 -> 467321 bytes swarm/examples/album/index.css | 291 +++++++ swarm/examples/album/index.html | 20 + swarm/examples/album/index.js | 836 ++++++++++++++++++++ swarm/examples/album/left.png | Bin 0 -> 686 bytes swarm/examples/album/mootools-core-1.4.js | 491 ++++++++++++ swarm/examples/album/mootools-idle.js | 198 +++++ swarm/examples/album/mootools-mooswipe.js | 77 ++ swarm/examples/album/mootools-more-1.4.js | 45 ++ swarm/examples/album/noise.png | Bin 0 -> 65982 bytes swarm/examples/album/right.png | Bin 0 -> 669 bytes swarm/examples/album/throbber.gif | Bin 0 -> 1657 bytes swarm/examples/album/up.png | Bin 0 -> 367 bytes swarm/examples/bzzhandler.html | 15 + swarm/network/depo.go | 190 +++++ swarm/network/forwarding.go | 131 +++ swarm/network/hive.go | 322 ++++++++ swarm/network/messages.go | 294 +++++++ swarm/network/protocol.go | 505 ++++++++++++ swarm/network/protocol_test.go | 1 + swarm/network/syncdb.go | 371 +++++++++ swarm/network/syncdb_test.go | 205 +++++ swarm/network/syncer.go | 762 ++++++++++++++++++ swarm/services/swap/swap.go | 271 +++++++ swarm/services/swear/doc.go | 3 + swarm/services/swear/swear.sol | 161 ++++ swarm/services/swear/swear_test.go | 1 + swarm/storage/chunker.go | 411 ++++++++++ swarm/storage/chunker_test.go | 214 +++++ swarm/storage/chunkreader.go | 194 +++++ swarm/storage/common_test.go | 94 +++ swarm/storage/database.go | 96 +++ swarm/storage/dbstore.go | 457 +++++++++++ swarm/storage/dbstore_test.go | 172 ++++ swarm/storage/dpa.go | 234 ++++++ swarm/storage/dpa_test.go | 133 ++++ swarm/storage/localstore.go | 53 ++ swarm/storage/memstore.go | 336 ++++++++ swarm/storage/memstore_test.go | 34 + swarm/storage/netstore.go | 117 +++ swarm/storage/types.go | 155 ++++ swarm/swarm.go | 231 ++++++ swarm/test/syncing/00.sh | 83 ++ swarm/test/test0/img/logo.png | Bin 0 -> 18136 bytes swarm/test/test0/index.css | 9 + swarm/test/test0/index.html | 10 + 103 files changed, 14314 insertions(+), 111 deletions(-) create mode 100644 cmd/geth/js_bzz_test.go create mode 100644 common/chequebook/cheque.go create mode 100644 common/chequebook/cheque_test.go create mode 100644 common/chequebook/chequebook.sol create mode 100644 common/chequebook/contract.go create mode 100644 common/kademlia/address.go create mode 100644 common/kademlia/address_test.go create mode 100644 common/kademlia/kaddb.go create mode 100644 common/kademlia/kademlia.go create mode 100644 common/kademlia/kademlia_test.go create mode 100644 common/swap/swap.go create mode 100644 common/swap/swap_test.go create mode 100644 rpc/api/bzz.go create mode 100644 rpc/api/bzz_args.go create mode 100644 rpc/api/bzz_js.go create mode 100644 swarm/api/api.go create mode 100644 swarm/api/api_test.go create mode 100644 swarm/api/config.go create mode 100644 swarm/api/config_test.go create mode 100644 swarm/api/ethereum.go create mode 100644 swarm/api/http.go create mode 100644 swarm/api/manifest.go create mode 100644 swarm/api/manifest_test.go create mode 100644 swarm/api/roundtripper.go create mode 100644 swarm/api/roundtripper_test.go create mode 100644 swarm/cmd/bzzhash/bzzhash.go create mode 100755 swarm/cmd/bzzup.sh create mode 100644 swarm/examples/album/add.png create mode 100644 swarm/examples/album/back.png create mode 100644 swarm/examples/album/cut-left.png create mode 100644 swarm/examples/album/cut-mov.png create mode 100644 swarm/examples/album/cut-right.png create mode 100644 swarm/examples/album/cut-top.png create mode 100644 swarm/examples/album/data.json create mode 100644 swarm/examples/album/delete.png create mode 100644 swarm/examples/album/down.png create mode 100644 swarm/examples/album/download.png create mode 100644 swarm/examples/album/eye.png create mode 100644 swarm/examples/album/imgs/apron.jpg create mode 100644 swarm/examples/album/imgs/bekas1.jpg create mode 100644 swarm/examples/album/imgs/bekas2.jpg create mode 100644 swarm/examples/album/imgs/bekas_blanik.jpg create mode 100644 swarm/examples/album/imgs/hangar.jpg create mode 100644 swarm/examples/album/imgs/hangar_inside.jpg create mode 100644 swarm/examples/album/imgs/ruin.jpg create mode 100644 swarm/examples/album/index.css create mode 100644 swarm/examples/album/index.html create mode 100644 swarm/examples/album/index.js create mode 100644 swarm/examples/album/left.png create mode 100644 swarm/examples/album/mootools-core-1.4.js create mode 100644 swarm/examples/album/mootools-idle.js create mode 100644 swarm/examples/album/mootools-mooswipe.js create mode 100644 swarm/examples/album/mootools-more-1.4.js create mode 100644 swarm/examples/album/noise.png create mode 100644 swarm/examples/album/right.png create mode 100644 swarm/examples/album/throbber.gif create mode 100644 swarm/examples/album/up.png create mode 100644 swarm/examples/bzzhandler.html create mode 100644 swarm/network/depo.go create mode 100644 swarm/network/forwarding.go create mode 100644 swarm/network/hive.go create mode 100644 swarm/network/messages.go create mode 100644 swarm/network/protocol.go create mode 100644 swarm/network/protocol_test.go create mode 100644 swarm/network/syncdb.go create mode 100644 swarm/network/syncdb_test.go create mode 100644 swarm/network/syncer.go create mode 100644 swarm/services/swap/swap.go create mode 100644 swarm/services/swear/doc.go create mode 100644 swarm/services/swear/swear.sol create mode 100644 swarm/services/swear/swear_test.go create mode 100644 swarm/storage/chunker.go create mode 100644 swarm/storage/chunker_test.go create mode 100644 swarm/storage/chunkreader.go create mode 100644 swarm/storage/common_test.go create mode 100644 swarm/storage/database.go create mode 100644 swarm/storage/dbstore.go create mode 100644 swarm/storage/dbstore_test.go create mode 100644 swarm/storage/dpa.go create mode 100644 swarm/storage/dpa_test.go create mode 100644 swarm/storage/localstore.go create mode 100644 swarm/storage/memstore.go create mode 100644 swarm/storage/memstore_test.go create mode 100644 swarm/storage/netstore.go create mode 100644 swarm/storage/types.go create mode 100644 swarm/swarm.go create mode 100644 swarm/test/syncing/00.sh create mode 100644 swarm/test/test0/img/logo.png create mode 100644 swarm/test/test0/index.css create mode 100644 swarm/test/test0/index.html diff --git a/accounts/account_manager.go b/accounts/account_manager.go index 74006395cd..2ada1a9804 100644 --- a/accounts/account_manager.go +++ b/accounts/account_manager.go @@ -91,6 +91,16 @@ func (am *Manager) Sign(a Account, toSign []byte) (signature []byte, err error) return signature, err } +func (am *Manager) GetUnlocked(addr common.Address) (prvkey *ecdsa.PrivateKey, err error) { + am.mutex.RLock() + defer am.mutex.RUnlock() + unlockedKey, found := am.unlocked[addr] + if !found { + return nil, ErrLocked + } + return unlockedKey.PrivateKey, nil +} + // Unlock unlocks the given account indefinitely. func (am *Manager) Unlock(addr common.Address, keyAuth string) error { return am.TimedUnlock(addr, keyAuth, 0) diff --git a/cmd/geth/js.go b/cmd/geth/js.go index 56b7a8b001..008b581024 100644 --- a/cmd/geth/js.go +++ b/cmd/geth/js.go @@ -24,9 +24,8 @@ import ( "os/signal" "path/filepath" "regexp" - "strings" - "sort" + "strings" "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/common" @@ -190,6 +189,8 @@ func newJSRE(stack *node.Node, docRoot, corsDomain string, client comms.Ethereum if clt, ok := js.client.(*comms.InProcClient); ok { if offeredApis, err := api.ParseApiString(shared.AllApis, codec.JSON, js.xeth, stack); err == nil { clt.Initialize(api.Merge(offeredApis...)) + } else { + utils.Fatalf("Unable to offer apis: %v", err) } } diff --git a/cmd/geth/js_bzz_test.go b/cmd/geth/js_bzz_test.go new file mode 100644 index 0000000000..2d8b70efb9 --- /dev/null +++ b/cmd/geth/js_bzz_test.go @@ -0,0 +1,83 @@ +package main + +import ( + "io/ioutil" + "os" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/node" + "github.com/ethereum/go-ethereum/swarm" + "github.com/ethereum/go-ethereum/swarm/api" +) + +var port = 8500 + +func bzzREPL(t *testing.T, configf func(*api.Config)) (string, string, *testjethre, *node.Node) { + prvKey, err := crypto.GenerateKey() + if err != nil { + t.Fatal("unable to generate key") + } + bzztmp, err := ioutil.TempDir("", "bzz-js-test") + config, err := api.NewConfig(bzztmp, common.Address{}, prvKey) + if err != nil { + t.Fatal("unable to configure swarm") + } + if configf != nil { + configf(config) + } + tmp, repl, stack := testREPL(t, func(n *node.Node) { + if err := n.Register(func(ctx *node.ServiceContext) (node.Service, error) { + return swarm.NewSwarm(ctx, config, false) + }); err != nil { + t.Fatalf("Failed to register the Swarm service: %v", err) + } + }) + return bzztmp, tmp, repl, stack +} + +func withREPL(t *testing.T, cf func(*api.Config), f func(repl *testjethre)) { + bzztmp, tmp, repl, stack := bzzREPL(t, cf) + defer stack.Stop() + defer os.RemoveAll(tmp) + defer os.RemoveAll(bzztmp) + f(repl) +} + +func TestBzzPutGet(t *testing.T) { + withREPL(t, + func(c *api.Config) { + c.Port = "" + }, func(repl *testjethre) { + if checkEvalJSON(t, repl, `hash = bzz.put("console.log(\"hello from console\")", "application/javascript")`, `"97f1b7c7ea12468fd37c262383b9aa862d0cfbc4fc7218652374679fc5cf40cd"`) != nil { + return + } + want := `{"content":"console.log(\"hello from console\")","contentType":"application/javascript","size":"33","status":"0"}` + if checkEvalJSON(t, repl, `bzz.get(hash)`, want) != nil { + return + } + }) +} + +// the server can be initialized only once per test session ! +// until we implement a stoppable http server +// further http tests will need to make sure the correct server is running +func TestHTTP(t *testing.T) { + withREPL(t, nil, func(repl *testjethre) { + if checkEvalJSON(t, repl, `hash = bzz.put("f42 = function() { return 42 }", "application/javascript")`, `"e6847876f00102441f850b2d438a06d10e3bf24e6a0a76d47b073a86c3c2f9ac"`) != nil { + return + } + if checkEvalJSON(t, repl, `admin.httpGet("bzz://"+hash)`, `"f42 = function() { return 42 }"`) != nil { + return + } + + // if checkEvalJSON(t, repl, `http.loadScript("bzz://"+hash)`, `true`) != nil { + // return + // } + + // if checkEvalJSON(t, repl, `f42()`, `42`) != nil { + // return + // } + }) +} diff --git a/cmd/geth/js_test.go b/cmd/geth/js_test.go index ca636188f4..975f8dde5e 100644 --- a/cmd/geth/js_test.go +++ b/cmd/geth/js_test.go @@ -91,7 +91,7 @@ func testJEthRE(t *testing.T) (string, *testjethre, *node.Node) { return testREPL(t, nil) } -func testREPL(t *testing.T, config func(*eth.Config)) (string, *testjethre, *node.Node) { +func testREPL(t *testing.T, config func(*node.Node)) (string, *testjethre, *node.Node) { tmp, err := ioutil.TempDir("", "geth-test") if err != nil { t.Fatal(err) @@ -107,17 +107,16 @@ func testREPL(t *testing.T, config func(*eth.Config)) (string, *testjethre, *nod db, _ := ethdb.NewMemDatabase() core.WriteGenesisBlockForTesting(db, core.GenesisAccount{common.HexToAddress(testAddress), common.String2Big(testBalance)}) + coinbase := common.HexToAddress(testAddress) ethConf := ð.Config{ TestGenesisState: db, AccountManager: accman, DocRoot: "/", SolcPath: testSolcPath, + Etherbase: coinbase, PowTest: true, } - if config != nil { - config(ethConf) - } if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) { return eth.New(ctx, ethConf) }); err != nil { t.Fatalf("failed to register ethereum protocol: %v", err) } @@ -133,6 +132,12 @@ func testREPL(t *testing.T, config func(*eth.Config)) (string, *testjethre, *nod if err := accman.Unlock(key.Address, ""); err != nil { t.Fatal(err) } + + // tests can register services here + if config != nil { + config(stack) + } + // Start the node and assemble the REPL tester if err := stack.Start(); err != nil { t.Fatalf("failed to start test stack: %v", err) @@ -267,10 +272,7 @@ func TestSignature(t *testing.T) { func TestContract(t *testing.T) { t.Skip("contract testing is implemented with mining in ethash test mode. This takes about 7seconds to run. Unskip and run on demand") coinbase := common.HexToAddress(testAddress) - tmp, repl, ethereum := testREPL(t, func(conf *eth.Config) { - conf.Etherbase = coinbase - conf.PowTest = true - }) + tmp, repl, ethereum := testREPL(t, nil) if err := ethereum.Start(); err != nil { t.Errorf("error starting ethereum: %v", err) return diff --git a/cmd/geth/main.go b/cmd/geth/main.go index bb291ccde2..6557de2df8 100644 --- a/cmd/geth/main.go +++ b/cmd/geth/main.go @@ -4,7 +4,7 @@ // go-ethereum is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. +// (at your option) any later version. // // go-ethereum is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -30,9 +30,7 @@ import ( "github.com/codegangsta/cli" "github.com/ethereum/ethash" - "github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/cmd/utils" - "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/logger/glog" @@ -316,6 +314,9 @@ JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Conso utils.IPCExperimental, utils.ExecFlag, utils.WhisperEnabledFlag, + utils.SwarmConfigPathFlag, + utils.SwarmAccountAddrFlag, + utils.ChequebookAddrFlag, utils.DevModeFlag, utils.TestNetFlag, utils.VMDebugFlag, @@ -427,6 +428,7 @@ func attach(ctx *cli.Context) { func console(ctx *cli.Context) { // Create and start the node based on the CLI flags node := utils.MakeSystemNode(ClientIdentifier, nodeNameVersion, makeDefaultExtra(), ctx) + startNode(ctx, node) // Attach to the newly started node, and either execute script or become interactive @@ -465,46 +467,14 @@ func execScripts(ctx *cli.Context) { node.Stop() } -// tries unlocking the specified account a few times. -func unlockAccount(ctx *cli.Context, accman *accounts.Manager, address string, i int, passwords []string) (common.Address, string) { - account, err := utils.MakeAddress(accman, address) - if err != nil { - utils.Fatalf("Unlock error: %v", err) - } - - for trials := 0; trials < 3; trials++ { - prompt := fmt.Sprintf("Unlocking account %s | Attempt %d/%d", address, trials+1, 3) - password := getPassPhrase(prompt, false, i, passwords) - if err := accman.Unlock(account, password); err == nil { - return account, password - } - } - // All trials expended to unlock account, bail out - utils.Fatalf("Failed to unlock account: %s", address) - return common.Address{}, "" -} - -// startNode boots up the system node and all registered protocols, after which -// it unlocks any requested accounts, and starts the RPC/IPC interfaces and the +// startNode unlocks any requested accounts the boots up the system node +// starts all registered protocols and +// starts the RPC/IPC interfaces and the // miner. func startNode(ctx *cli.Context, stack *node.Node) { // Start up the node itself utils.StartNode(stack) - // Unlock any account specifically requested - var ethereum *eth.Ethereum - if err := stack.Service(ðereum); err != nil { - utils.Fatalf("ethereum service not running: %v", err) - } - accman := ethereum.AccountManager() - passwords := utils.MakePasswordList(ctx) - - accounts := strings.Split(ctx.GlobalString(utils.UnlockedAccountFlag.Name), ",") - for i, account := range accounts { - if trimmed := strings.TrimSpace(account); trimmed != "" { - unlockAccount(ctx, accman, trimmed, i, passwords) - } - } // Start auxiliary services if enabled. if !ctx.GlobalBool(utils.IPCDisabledFlag.Name) { if err := utils.StartIPC(stack, ctx); err != nil { @@ -516,6 +486,10 @@ func startNode(ctx *cli.Context, stack *node.Node) { utils.Fatalf("Failed to start RPC: %v", err) } } + var ethereum *eth.Ethereum + if err := stack.Service(ðereum); err != nil { + utils.Fatalf("ethereum service not running: %v", err) + } if ctx.GlobalBool(utils.MiningEnabledFlag.Name) { if err := ethereum.StartMining(ctx.GlobalInt(utils.MinerThreadsFlag.Name), ctx.GlobalString(utils.MiningGPUFlag.Name)); err != nil { utils.Fatalf("Failed to start mining: %v", err) @@ -534,38 +508,10 @@ func accountList(ctx *cli.Context) { } } -// getPassPhrase retrieves the passwor associated with an account, either fetched -// from a list of preloaded passphrases, or requested interactively from the user. -func getPassPhrase(prompt string, confirmation bool, i int, passwords []string) string { - // If a list of passwords was supplied, retrieve from them - if len(passwords) > 0 { - if i < len(passwords) { - return passwords[i] - } - return passwords[len(passwords)-1] - } - // Otherwise prompt the user for the password - fmt.Println(prompt) - password, err := utils.PromptPassword("Passphrase: ", true) - if err != nil { - utils.Fatalf("Failed to read passphrase: %v", err) - } - if confirmation { - confirm, err := utils.PromptPassword("Repeat passphrase: ", false) - if err != nil { - utils.Fatalf("Failed to read passphrase confirmation: %v", err) - } - if password != confirm { - utils.Fatalf("Passphrases do not match") - } - } - return password -} - // accountCreate creates a new account into the keystore defined by the CLI flags. func accountCreate(ctx *cli.Context) { accman := utils.MakeAccountManager(ctx) - password := getPassPhrase("Your new account is locked with a password. Please give a password. Do not forget this password.", true, 0, utils.MakePasswordList(ctx)) + password := utils.GetPassPhrase("Your new account is locked with a password. Please give a password. Do not forget this password.", true, 0, utils.MakePasswordList(ctx)) account, err := accman.NewAccount(password) if err != nil { @@ -582,8 +528,8 @@ func accountUpdate(ctx *cli.Context) { } accman := utils.MakeAccountManager(ctx) - account, oldPassword := unlockAccount(ctx, accman, ctx.Args().First(), 0, nil) - newPassword := getPassPhrase("Please give a new password. Do not forget this password.", true, 0, nil) + account, oldPassword := utils.UnlockAccount(ctx, accman, ctx.Args().First(), 0, nil) + newPassword := utils.GetPassPhrase("Please give a new password. Do not forget this password.", true, 0, nil) if err := accman.Update(account, oldPassword, newPassword); err != nil { utils.Fatalf("Could not update the account: %v", err) } @@ -600,7 +546,7 @@ func importWallet(ctx *cli.Context) { } accman := utils.MakeAccountManager(ctx) - passphrase := getPassPhrase("", false, 0, utils.MakePasswordList(ctx)) + passphrase := utils.GetPassPhrase("", false, 0, utils.MakePasswordList(ctx)) acct, err := accman.ImportPreSaleKey(keyJson, passphrase) if err != nil { @@ -615,7 +561,7 @@ func accountImport(ctx *cli.Context) { utils.Fatalf("keyfile must be given as argument") } accman := utils.MakeAccountManager(ctx) - passphrase := getPassPhrase("Your new account is locked with a password. Please give a password. Do not forget this password.", true, 0, utils.MakePasswordList(ctx)) + passphrase := utils.GetPassPhrase("Your new account is locked with a password. Please give a password. Do not forget this password.", true, 0, utils.MakePasswordList(ctx)) acct, err := accman.Import(keyfile, passphrase) if err != nil { utils.Fatalf("Could not create the account: %v", err) diff --git a/cmd/utils/customflags.go b/cmd/utils/customflags.go index 4450065c14..faf531121d 100644 --- a/cmd/utils/customflags.go +++ b/cmd/utils/customflags.go @@ -39,7 +39,7 @@ func (self *DirectoryString) String() string { } func (self *DirectoryString) Set(value string) error { - self.Value = expandPath(value) + self.Value = ExpandPath(value) return nil } @@ -135,7 +135,7 @@ func (self *DirectoryFlag) Set(value string) { // 2. expands embedded environment variables // 3. cleans the path, e.g. /a/b/../c -> /a/c // Note, it has limitations, e.g. ~someuser/tmp will not be expanded -func expandPath(p string) string { +func ExpandPath(p string) string { if strings.HasPrefix(p, "~/") || strings.HasPrefix(p, "~\\") { if user, err := user.Current(); err == nil { p = user.HomeDir + p[1:] diff --git a/cmd/utils/customflags_test.go b/cmd/utils/customflags_test.go index de39ca36a1..05e47abe4d 100644 --- a/cmd/utils/customflags_test.go +++ b/cmd/utils/customflags_test.go @@ -33,7 +33,7 @@ func TestPathExpansion(t *testing.T) { } os.Setenv("DDDXXX", "/tmp") for test, expected := range tests { - got := expandPath(test) + got := ExpandPath(test) if got != expected { t.Errorf("test %s, got %s, expected %s\n", test, got, expected) } diff --git a/cmd/utils/flags.go b/cmd/utils/flags.go index abee6210f3..0e65daa7cb 100644 --- a/cmd/utils/flags.go +++ b/cmd/utils/flags.go @@ -55,6 +55,8 @@ import ( "github.com/ethereum/go-ethereum/rpc/shared" "github.com/ethereum/go-ethereum/rpc/useragent" rpc "github.com/ethereum/go-ethereum/rpc/v2" + "github.com/ethereum/go-ethereum/swarm" + bzzapi "github.com/ethereum/go-ethereum/swarm/api" "github.com/ethereum/go-ethereum/whisper" "github.com/ethereum/go-ethereum/xeth" ) @@ -351,6 +353,22 @@ var ( Name: "shh", Usage: "Enable Whisper", } + ChequebookAddrFlag = cli.StringFlag{ + Name: "chequebook", + Usage: "chequebook contract address", + } + SwarmAccountAddrFlag = cli.StringFlag{ + Name: "bzzaccount", + Usage: "Swarm account address (swarm disabled if empty)", + } + SwarmConfigPathFlag = cli.StringFlag{ + Name: "bzzconfig", + Usage: "Swarm config file path (datadir/bzz)", + } + SwarmSwapDisabled = cli.BoolFlag{ + Name: "bzznoswap", + Usage: "Swarm SWAP disabled (false)", + } // ATM the url is left to the user and deployment to JSpathFlag = cli.StringFlag{ Name: "jspath", @@ -582,6 +600,53 @@ func MakePasswordList(ctx *cli.Context) []string { return nil } +func UnlockAccount(ctx *cli.Context, accman *accounts.Manager, address string, i int, passwords []string) (common.Address, string) { + // Try to unlock the specified account a few times + account, err := MakeAddress(accman, address) + if err != nil { + Fatalf("unable to unlock account %v: %v", address, err) + } + + for trials := 0; trials < 3; trials++ { + prompt := fmt.Sprintf("Unlocking account %s | Attempt %d/%d", address, trials+1, 3) + password := GetPassPhrase(prompt, false, i, passwords) + if err := accman.Unlock(account, password); err == nil { + return account, password + } + } + // All trials expended to unlock account, bail out + Fatalf("Failed to unlock account: %s", address) + return common.Address{}, "" +} + +// getPassPhrase retrieves the passwor associated with an account, either fetched +// from a list of preloaded passphrases, or requested interactively from the user. +func GetPassPhrase(prompt string, confirmation bool, i int, passwords []string) string { + // If a list of passwords was supplied, retrieve from them + if len(passwords) > 0 { + if i < len(passwords) { + return passwords[i] + } + return passwords[len(passwords)-1] + } + // Otherwise prompt the user for the password + fmt.Println(prompt) + password, err := PromptPassword("Passphrase: ", true) + if err != nil { + Fatalf("Failed to read passphrase: %v", err) + } + if confirmation { + confirm, err := PromptPassword("Repeat passphrase: ", false) + if err != nil { + Fatalf("Failed to read passphrase confirmation: %v", err) + } + if password != confirm { + Fatalf("Passphrases do not match") + } + } + return password +} + // MakeSystemNode sets up a local node, configures the services to launch and // assembles the P2P protocol stack. func MakeSystemNode(name, version string, extra []byte, ctx *cli.Context) *node.Node { @@ -595,10 +660,12 @@ func MakeSystemNode(name, version string, extra []byte, ctx *cli.Context) *node. if networks > 1 { Fatalf("The %v flags are mutually exclusive", netFlags) } + datadir := MustMakeDataDir(ctx) + netprv := MakeNodeKey(ctx) // Configure the node's service container stackConf := &node.Config{ - DataDir: MustMakeDataDir(ctx), - PrivateKey: MakeNodeKey(ctx), + DataDir: datadir, + PrivateKey: netprv, Name: MakeNodeName(name, version, ctx), NoDiscovery: ctx.GlobalBool(NoDiscoverFlag.Name), BootstrapNodes: MakeBootstrapNodes(ctx), @@ -609,6 +676,14 @@ func MakeSystemNode(name, version string, extra []byte, ctx *cli.Context) *node. } // Configure the Ethereum service accman := MakeAccountManager(ctx) + passwords := MakePasswordList(ctx) + + accounts := strings.Split(ctx.GlobalString(UnlockedAccountFlag.Name), ",") + for i, account := range accounts { + if trimmed := strings.TrimSpace(account); trimmed != "" { + UnlockAccount(ctx, accman, trimmed, i, passwords) + } + } ethConf := ð.Config{ Genesis: MakeGenesisBlock(ctx), @@ -685,17 +760,49 @@ func MakeSystemNode(name, version string, extra []byte, ctx *cli.Context) *node. if err != nil { Fatalf("Failed to create the protocol stack: %v", err) } + + // eth.Ethereum: ethereum if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) { return eth.New(ctx, ethConf) }); err != nil { Fatalf("Failed to register the Ethereum service: %v", err) } + + // Whisper if shhEnable { if err := stack.Register(func(*node.ServiceContext) (node.Service, error) { return whisper.New(), nil }); err != nil { Fatalf("Failed to register the Whisper service: %v", err) } } + // bzz. Swarm + var bzzconfig *bzzapi.Config + hexaddr := ctx.GlobalString(SwarmAccountAddrFlag.Name) + if hexaddr != "" { + swarmaccount := common.HexToAddress(hexaddr) + if !accman.HasAccount(swarmaccount) { + Fatalf("swarm account '%v' does not exist: %v", hexaddr, err) + } + prvkey, err := accman.GetUnlocked(swarmaccount) + if err != nil { + Fatalf("unable to unlock swarm account: %v", err) + } + chbookaddr := common.HexToAddress(ctx.GlobalString(ChequebookAddrFlag.Name)) + bzzdir := ctx.GlobalString(SwarmConfigPathFlag.Name) + if bzzdir == "" { + bzzdir = filepath.Join(datadir, "bzz") + } + bzzconfig, err = bzzapi.NewConfig(bzzdir, chbookaddr, prvkey) + if err != nil { + Fatalf("unable to configure swarm: %v", err) + } + swap := ctx.GlobalBool(SwarmSwapDisabled.Name) + if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) { + return swarm.NewSwarm(ctx, bzzconfig, swap) + }); err != nil { + Fatalf("Failed to register the Swarm service: %v", err) + } + } return stack } diff --git a/common/bytes.go b/common/bytes.go index c6e2cd3127..ba6987a9ec 100644 --- a/common/bytes.go +++ b/common/bytes.go @@ -23,14 +23,9 @@ import ( "encoding/hex" "fmt" "math/big" - "regexp" "strings" ) -var ( - hexRe = regexp.MustCompile("^(0x)?([a-fA-f0-9]{2})+$") -) - func ToHex(b []byte) string { hex := Bytes2Hex(b) // Prefer output of "0x0" instead of "0x" @@ -144,14 +139,8 @@ func HasHexPrefix(str string) bool { } func IsHex(str string) bool { - return hexRe.MatchString(str) -} - -func NormaliseHex(str string) (string, bool) { - if HasHexPrefix(str) { - str = str[2:] - } - return str, IsHex(str) + l := len(str) + return l >= 4 && l%2 == 0 && str[0:2] == "0x" } func Bytes2Hex(d []byte) string { @@ -213,8 +202,8 @@ func ParseData(data ...interface{}) (ret []byte) { switch t := item.(type) { case string: var str []byte - if n, ok := NormaliseHex(t); ok { - str = Hex2Bytes(n) + if IsHex(t) { + str = Hex2Bytes(t[2:]) } else { str = []byte(t) } diff --git a/common/chequebook/cheque.go b/common/chequebook/cheque.go new file mode 100644 index 0000000000..41c89418b0 --- /dev/null +++ b/common/chequebook/cheque.go @@ -0,0 +1,660 @@ +package chequebook + +import ( + "bytes" + "crypto/ecdsa" + "encoding/json" + "fmt" + "io/ioutil" + "math/big" + "os" + "sync" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/swap" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/logger/glog" +) + +/* +Chequebook package is a go API to the 'chequebook' ethereum smart contract +With convenience methods that allow using chequebook for +* issuing, receiving, verifying cheques in ether +* (auto)cashing cheques in ether +* (auto)depositing ether to the chequebook contract +TODO: +* watch peer solvency and notify of bouncing cheques +* enable paying with cheque by signing off + +Some functionality require interacting with the blockchain: +* setting current balance on peer's chequebook +* sending the transaction to cash the cheque +* depositing ether to the chequebook +* watching incoming ether + +Backend is the interface for that +*/ + +const ( + gasToCash = "2000000" // gas cost of a cash transaction using chequebook + getSentAbiPre = "d75d691d" // sent amount accessor in the chequebook contract + cashAbiPre = "fbf788d6" // abi preamble signature for cash method of the chequebook + queryInterval = 15000000000 // 15 seconds + deployGas = "3000000" + // confirmationInterval = 3 * 10 * *11 // 5 minutes +) + +// Backend is the interface to interact with the Ethereum blockchain +// implemented by xeth.XEth +type Backend interface { + Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) + Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, string, error) + GetTxReceipt(txhash common.Hash) *types.Receipt + CodeAt(address string) string +} + +// rlp serialised cheque model for use with the chequebook +type Cheque struct { + // the address of the contract itself needed to avoid cross-contract submission + Contract common.Address // contract address + Beneficiary common.Address // beneficiary + Amount *big.Int // cumulative amount of all funds sent + Sig []byte // signature Sign(Sha3(contract, beneficiary, amount), prvKey) +} + +type Params struct { + ContractCode, ContractAbi, ContractSource string +} + +var ContractParams = &Params{ContractCode, ContractAbi, ContractSource} + +func (self *Cheque) String() string { + return fmt.Sprintf("contract: %s, beneficiary: %s, amount: %v, signature: %x", self.Contract.Hex(), self.Beneficiary.Hex(), self.Amount, self.Sig) +} + +// chequebook to create, sign cheques from single contract to multiple beneficiarys +// outgoing payment handler for peer to peer micropayments +type Chequebook struct { + path string // path to chequebook file + prvKey *ecdsa.PrivateKey // private key to sign cheque with + lock sync.Mutex // + backend Backend // blockchain API + quit chan bool // when closed causes autodeposit to stop + owner common.Address // owner address (derived from pubkey) + + // persisted fields + balance *big.Int // not synced with blockchain + contract common.Address // contract address + sent map[common.Address]*big.Int //tallies for beneficiarys + + txhash string // tx hash of last deposit tx + threshold *big.Int // threshold that triggers autodeposit if not nil + buffer *big.Int // buffer to keep on top of balance for fork protection +} + +func Deploy(owner common.Address, backend Backend, amount *big.Int, confirmationInterval, timeout time.Duration) (contract common.Address, err error) { + if (owner == common.Address{}) { + return contract, fmt.Errorf("invalid owner %v. Owner needed to deploy chequebook contract: %v", owner.Hex(), err) + } + + txhash, err := backend.Transact(owner.Hex(), "", "", amount.String(), deployGas, "", ContractCode) + if err != nil { + return contract, fmt.Errorf("unable to send chequebook creation transaction: %v", err) + } + + timer := time.NewTimer(timeout).C + ticker := time.NewTicker(queryInterval).C +OUT: + for { + select { + + case <-timer: + if ticker == nil { + // ticker is nil, receipt was found and confirmation interval passed + err = Validate(contract, backend) + if err != nil { + return contract, fmt.Errorf("invalid contract at %v after %v: %v", contract.Hex(), confirmationInterval, err) + } + break OUT + } + // ticker is non-nil meaning receipt not found yet + return contract, fmt.Errorf("chequebook deployment timed out in %v", timeout) + + case <-ticker: + receipt := backend.GetTxReceipt(common.HexToHash(txhash)) + if receipt != nil { + contract = receipt.ContractAddress + glog.V(logger.Detail).Infof("[CHEQUEBOOK] chequebook deployed at %v (owner: %v)", contract.Hex(), owner.Hex()) + timer = time.NewTimer(confirmationInterval).C + ticker = nil + } else { + glog.V(logger.Detail).Infof("[CHEQUEBOOK] check if chequebook deployed (txhash: %v)", txhash) + } + + } + } + return contract, nil +} + +func Validate(contract common.Address, backend Backend) (err error) { + if (contract == common.Address{}) { + return fmt.Errorf("zero address") + } + code := backend.CodeAt(contract.Hex()) + if code != ContractDeployedCode { + return fmt.Errorf("incorrect code %v:\n%v\n%v", contract.Hex(), code, ContractDeployedCode) + } + return nil +} + +// NewChequebook(path, contract, balance, prvKey) creates a new Chequebook +func NewChequebook(path string, contract common.Address, prvKey *ecdsa.PrivateKey, backend Backend) (self *Chequebook, err error) { + balance := new(big.Int) + sent := make(map[common.Address]*big.Int) + owner := crypto.PubkeyToAddress(prvKey.PublicKey) + self = &Chequebook{ + balance: balance, + contract: contract, + sent: sent, + path: path, + prvKey: prvKey, + backend: backend, + owner: owner, + } + if (contract != common.Address{}) { + glog.V(logger.Detail).Infof("[CHEQUEBOOK] new chequebook initialised from %v (owner: %v)", contract.Hex(), owner.Hex()) + } + return +} + +// LoadChequebook(path, prvKey, backend) loads a chequebook from disk (file path) +func LoadChequebook(path string, prvKey *ecdsa.PrivateKey, backend Backend) (self *Chequebook, err error) { + var data []byte + data, err = ioutil.ReadFile(path) + if err != nil { + return + } + + self, _ = NewChequebook(path, common.Address{}, prvKey, backend) + + err = json.Unmarshal(data, self) + if err != nil { + return nil, err + } + glog.V(logger.Detail).Infof("[CHEQUEBOOK] loaded chequebook (%s, owner: %v) initialised from %v", self.contract.Hex(), self.owner.Hex(), path) + + return +} + +// chequebook serialisation +type chequebookFile struct { + Balance string + Contract string + Owner string + Sent map[string]string +} + +func (self *Chequebook) UnmarshalJSON(data []byte) error { + var file chequebookFile + err := json.Unmarshal(data, &file) + if err != nil { + return err + } + _, ok := self.balance.SetString(file.Balance, 10) + if !ok { + return fmt.Errorf("cumulative amount sent: unable to convert string to big integer: %v", file.Balance) + } + self.contract = common.HexToAddress(file.Contract) + for addr, sent := range file.Sent { + self.sent[common.HexToAddress(addr)], ok = new(big.Int).SetString(sent, 10) + if !ok { + return fmt.Errorf("beneficiary %v cumulative amount sent: unable to convert string to big integer: %v", addr, sent) + } + } + return nil +} + +func (self *Chequebook) MarshalJSON() ([]byte, error) { + var file = &chequebookFile{ + Balance: self.balance.String(), + Contract: self.contract.Hex(), + Owner: self.owner.Hex(), + Sent: make(map[string]string), + } + for addr, sent := range self.sent { + file.Sent[addr.Hex()] = sent.String() + } + return json.Marshal(file) +} + +// Save() persists the chequebook on disk +// remembers balance, contract address and +// cumulative amount of funds sent for each beneficiary +func (self *Chequebook) Save() (err error) { + data, err := json.MarshalIndent(self, "", " ") + if err != nil { + return err + } + glog.V(logger.Detail).Infof("[CHEQUEBOOK] saving chequebook (%s) to %v", self.contract.Hex(), self.path) + + return ioutil.WriteFile(self.path, data, os.ModePerm) +} + +// Stop() quits the autodeposit go routine to terminate +func (self *Chequebook) Stop() { + defer self.lock.Unlock() + self.lock.Lock() + if self.quit != nil { + close(self.quit) + self.quit = nil + } +} + +// Issue(beneficiary, amount) will create a Cheque +// the cheque is signed by the chequebook owner's private key +// the signer commits to a contract (one that they own), a beneficiary and amount +func (self *Chequebook) Issue(beneficiary common.Address, amount *big.Int) (ch *Cheque, err error) { + defer self.lock.Unlock() + self.lock.Lock() + if amount.Cmp(common.Big0) <= 0 { + return nil, fmt.Errorf("amount must be greater than zero (%v)", amount) + } + if self.balance.Cmp(amount) < 0 { + err = fmt.Errorf("insufficent funds to issue cheque for amount: %v. balance: %v", amount, self.balance) + } else { + var sig []byte + sent, found := self.sent[beneficiary] + if !found { + sent = new(big.Int) + self.sent[beneficiary] = sent + } + sum := new(big.Int).Set(sent) + sum.Add(sum, amount) + sig, err = crypto.Sign(sigHash(self.contract, beneficiary, sum), self.prvKey) + if err == nil { + ch = &Cheque{ + Contract: self.contract, + Beneficiary: beneficiary, + Amount: sum, + Sig: sig, + } + sent.Set(sum) + self.balance.Sub(self.balance, amount) // subtract amount from balance + } + } + + // auto deposit if threshold is set and balance is less then threshold + // note this is called even if issueing cheque fails + // so we reattempt depositing + if self.threshold != nil { + if self.balance.Cmp(self.threshold) < 0 { + send := new(big.Int).Sub(self.buffer, self.balance) + self.deposit(send) + } + } + + return +} + +// convenience method to cash any cheque +func (self *Chequebook) Cash(ch *Cheque) (txhash string, err error) { + return ch.Cash(self.owner, self.backend) +} + +// data to sign: contract address, beneficiary, cumulative amount of funds ever sent +func sigHash(contract, beneficiary common.Address, sum *big.Int) []byte { + bigamount := sum.Bytes() + if len(bigamount) > 32 { + return nil + } + var amount32 [32]byte + copy(amount32[32-len(bigamount):32], bigamount) + input := append(contract.Bytes(), beneficiary.Bytes()...) + input = append(input, amount32[:]...) + return crypto.Sha3(input) +} + +// Balance() public accessor for balance +func (self *Chequebook) Balance() *big.Int { + defer self.lock.Unlock() + self.lock.Lock() + return new(big.Int).Set(self.balance) +} + +// Balance() public accessor for balance +func (self *Chequebook) Owner() common.Address { + return self.owner +} + +// Backend() public accessor for backend +func (self *Chequebook) Backend() Backend { + return self.backend +} + +// Address() public accessor for contract +func (self *Chequebook) Address() common.Address { + return self.contract +} + +// Deposit(amount) deposits amount to the chequebook account +func (self *Chequebook) Deposit(amount *big.Int) (string, error) { + defer self.lock.Unlock() + self.lock.Lock() + return self.deposit(amount) +} + +// deposit(amount) deposits amount to the chequebook account +// caller holds the lock +func (self *Chequebook) deposit(amount *big.Int) (string, error) { + txhash, err := self.backend.Transact(self.owner.Hex(), self.contract.Hex(), "", amount.String(), "", "", "") + // assume that transaction is actually successful, we add the amount to balance right away + if err != nil { + glog.V(logger.Warn).Infof("[CHEQUEBOOK] error depositing %d wei to chequebook (%s, balance: %v, target: %v): %v", amount, self.contract.Hex(), self.balance, self.buffer, err) + } else { + self.balance.Add(self.balance, amount) + glog.V(logger.Detail).Infof("[CHEQUEBOOK] deposited %d wei to chequebook (%s, balance: %v, target: %v)", amount, self.contract.Hex(), self.balance, self.buffer) + } + return txhash, err +} + +// AutoDeposit(interval, threshold, buffer) (re)sets interval time and amount +// which triggers sending funds to the chequebook contract +// backend needs to be set +// if threshold is not less than buffer, then deposit will be triggered on +// every new cheque issued +func (self *Chequebook) AutoDeposit(interval time.Duration, threshold, buffer *big.Int) { + defer self.lock.Unlock() + self.lock.Lock() + self.threshold = threshold + self.buffer = buffer + self.autoDeposit(interval) +} + +// autoDeposit(interval) starts a go routine that periodically sends funds to the +// chequebook contract +// caller holds the lock +// the go routine terminates if Chequebook.quit us closed +func (self *Chequebook) autoDeposit(interval time.Duration) { + if self.quit != nil { + close(self.quit) + self.quit = nil + } + // if threshold >= balance autodeposit after every cheque issued + if interval == time.Duration(0) || self.threshold != nil && self.buffer != nil && self.threshold.Cmp(self.buffer) >= 0 { + return + } + + ticker := time.NewTicker(interval) + self.quit = make(chan bool) + quit := self.quit + go func() { + FOR: + for { + select { + case <-quit: + break FOR + case <-ticker.C: + self.lock.Lock() + if self.balance.Cmp(self.buffer) < 0 { + amount := new(big.Int).Sub(self.buffer, self.balance) + txhash, err := self.deposit(amount) + if err == nil { + self.txhash = txhash + } + } + self.lock.Unlock() + } + } + }() + return +} + +type Outbox struct { + chequeBook *Chequebook + beneficiary common.Address +} + +func NewOutbox(chbook *Chequebook, beneficiary common.Address) *Outbox { + return &Outbox{chbook, beneficiary} +} + +func (self *Outbox) Issue(amount *big.Int) (swap.Promise, error) { + return self.chequeBook.Issue(self.beneficiary, amount) +} + +func (self *Outbox) AutoDeposit(interval time.Duration, threshold, buffer *big.Int) { + self.chequeBook.AutoDeposit(interval, threshold, buffer) +} + +func (self *Outbox) Stop() {} + +func (self *Outbox) String() string { + return fmt.Sprintf("chequebook: %v, beneficiary: %s, balance: %v", self.chequeBook.Address().Hex(), self.beneficiary.Hex(), self.chequeBook.Balance()) +} + +// type ChequeQueue struct { +// beneficiary common.Address +// last map[string]*Inbox +// } + +// inbox to deposit, verify and cash cheques +// from a single contract to single beneficiary +// incoming payment handler for peer to peer micropayments +type Inbox struct { + lock sync.Mutex + contract common.Address // peer's chequebook contract + beneficiary common.Address // local peer's receiving address + sender common.Address // local peer's address to send cashing tx from + signer *ecdsa.PublicKey // peer's public key + txhash string // tx hash of last cashing tx + backend Backend // blockchain API + quit chan bool // when closed causes autocash to stop + maxUncashed *big.Int // threshold that triggers autocashing + cashed *big.Int // cumulative amount cashed + cheque *Cheque // last cheque, nil if none yet received +} + +// NewInbox(contract, beneficiary, signer, backend) constructor for Inbox +// not persisted, cumulative sum updated from blockchain when first cheque received +// backend used to sync amount (Call) as well as cash the cheques (Transact) +func NewInbox(contract, sender, beneficiary common.Address, signer *ecdsa.PublicKey, backend Backend) (self *Inbox, err error) { + + if signer == nil { + return nil, fmt.Errorf("signer is null") + } + + self = &Inbox{ + contract: contract, + beneficiary: beneficiary, + sender: sender, + signer: signer, + backend: backend, + cashed: new(big.Int).Set(common.Big0), + } + glog.V(logger.Detail).Infof("[CHEQUEBOOK] initialised inbox (%s -> %s) expected signer: %x", self.contract.Hex(), self.beneficiary.Hex(), crypto.FromECDSAPub(signer)) + return +} + +func (self *Inbox) String() string { + return fmt.Sprintf("chequebook: %v, beneficiary: %s, balance: %v", self.contract.Hex(), self.beneficiary.Hex(), self.cheque.Amount) +} + +// Stop() quits the autocash go routine to terminate +func (self *Inbox) Stop() { + defer self.lock.Unlock() + self.lock.Lock() + if self.quit != nil { + close(self.quit) + self.quit = nil + } +} + +func (self *Inbox) Cash() (txhash string, err error) { + if self.cheque != nil { + txhash, err = self.cheque.Cash(self.sender, self.backend) + glog.V(logger.Detail).Infof("[CHEQUEBOOK] cashing cheque (total: %v) on chequebook (%s) sending to %v", self.cheque.Amount, self.contract.Hex(), self.beneficiary.Hex()) + self.cashed = self.cheque.Amount + } + return +} + +// AutoCash(cashInterval, maxUncashed) (re)sets maximum time and amount which +// triggers cashing of the last uncashed cheque +// if maxUncashed is set to 0, then autocash on receipt +func (self *Inbox) AutoCash(cashInterval time.Duration, maxUncashed *big.Int) { + defer self.lock.Unlock() + self.lock.Lock() + self.maxUncashed = maxUncashed + self.autoCash(cashInterval) +} + +// autoCash(d) starts a loop that periodically clears the last check +// if the peer is trusted, clearing period could be 24h, or a week +// caller holds the lock +func (self *Inbox) autoCash(cashInterval time.Duration) { + if self.quit != nil { + close(self.quit) + self.quit = nil + } + // if maxUncashed is set to 0, then autocash on receipt + if cashInterval == time.Duration(0) || self.maxUncashed != nil && self.maxUncashed.Cmp(common.Big0) == 0 { + return + } + + ticker := time.NewTicker(cashInterval) + self.quit = make(chan bool) + quit := self.quit + go func() { + FOR: + for { + select { + case <-quit: + break FOR + case <-ticker.C: + self.lock.Lock() + if self.cheque != nil && self.cheque.Amount.Cmp(self.cashed) != 0 { + txhash, err := self.Cash() + if err == nil { + self.txhash = txhash + } + } + self.lock.Unlock() + } + } + }() + return +} + +// Reveive(cheque) called to deposit latest cheque to incoming Inbox +func (self *Inbox) Receive(promise swap.Promise) (*big.Int, error) { + ch := promise.(*Cheque) + + defer self.lock.Unlock() + self.lock.Lock() + var sum *big.Int + if self.cheque == nil { + // the sum is checked against the blockchain once a check is received + tallyhex, _, err := self.backend.Call(self.beneficiary.Hex(), self.contract.Hex(), "", "", "", getSentAbiEncode(ch.Contract)) + if err != nil { + return nil, fmt.Errorf("inbox: error calling backend to set amount: %v", err) + } + + tally := common.FromHex(tallyhex) + // var ok bool + // sum, ok = new(big.Int).SetString(tally, 10) + // if !ok { + // return nil, fmt.Errorf("inbox: cannot convert amount '%s' (%v) to integer", tallyhex, tally) + // } + sum = new(big.Int).SetBytes(tally) + } else { + sum = self.cheque.Amount + } + + amount, err := ch.Verify(self.signer, self.contract, self.beneficiary, sum) + var uncashed *big.Int + if err == nil { + self.cheque = ch + + if self.maxUncashed != nil { + uncashed = new(big.Int).Sub(ch.Amount, self.cashed) + if self.maxUncashed.Cmp(uncashed) < 0 { + self.Cash() + } + } + glog.V(logger.Detail).Infof("[CHEQUEBOOK] received cheque of %v wei in inbox (%s, uncashed: %v)", amount, self.contract.Hex(), uncashed) + } + + return amount, err +} + +// RSV representation of signature +func sig2rsv(sig []byte) (v byte, r, s []byte) { + v = sig[64] + 27 + r = sig[:32] + s = sig[32:64] + return +} + +func getSentAbiEncode(beneficiary common.Address) string { + var beneficiary32 [32]byte + copy(beneficiary32[12:], beneficiary.Bytes()) + return getSentAbiPre + common.Bytes2Hex(beneficiary32[:]) +} + +// abi encoding of a cheque to send as eth tx data +func (self *Cheque) cashAbiEncode() string { + v, r, s := sig2rsv(self.Sig) + // cashAbiPre, beneficiary, amount, v, r, s + bigamount := self.Amount.Bytes() + if len(bigamount) > 32 { + glog.V(logger.Detail).Infof("[CHEQUEBOOK] number too big: %v (>32 bytes)", self.Amount) + return "" + } + var beneficiary32, amount32, vabi [32]byte + copy(beneficiary32[12:], self.Beneficiary.Bytes()) + copy(amount32[32-len(bigamount):32], bigamount) + vabi[31] = v + return cashAbiPre + common.Bytes2Hex(beneficiary32[:]) + common.Bytes2Hex(amount32[:]) + + common.Bytes2Hex(vabi[:]) + common.Bytes2Hex(r) + common.Bytes2Hex(s) +} + +// Verify(cheque) verifies cheque for signer, contract, beneficiary, amount, valid signature +func (self *Cheque) Verify(signerKey *ecdsa.PublicKey, contract, beneficiary common.Address, sum *big.Int) (*big.Int, error) { + glog.V(logger.Detail).Infof("[CHEQUEBOOK] verify cheque: %v - sum: %v", self, sum) + if sum == nil { + return nil, fmt.Errorf("invalid amount") + } + + if self.Beneficiary != beneficiary { + return nil, fmt.Errorf("beneficiary mismatch: %v != %v", self.Beneficiary.Hex(), beneficiary.Hex()) + } + if self.Contract != contract { + return nil, fmt.Errorf("contract mismatch: %v != %v", self.Contract.Hex(), contract.Hex()) + } + + amount := new(big.Int).Set(self.Amount) + if sum != nil { + amount.Sub(amount, sum) + if amount.Cmp(common.Big0) <= 0 { + return nil, fmt.Errorf("incorrect amount: %v <= 0", amount) + } + } + + pubKey, err := crypto.SigToPub(sigHash(self.Contract, beneficiary, self.Amount), self.Sig) + if err != nil { + return nil, fmt.Errorf("invalid signature: %v", err) + } + if !bytes.Equal(crypto.FromECDSAPub(pubKey), crypto.FromECDSAPub(signerKey)) { + return nil, fmt.Errorf("signer mismatch: %x != %x", crypto.FromECDSAPub(pubKey), crypto.FromECDSAPub(signerKey)) + } + return amount, nil +} + +// Cash(backend) will cash the check using xeth backend to send a transaction +// Beneficiary address should be unlocked +func (self *Cheque) Cash(sender common.Address, backend Backend) (string, error) { + return backend.Transact(sender.Hex(), self.Contract.Hex(), "", "", "", gasToCash, self.cashAbiEncode()) +} diff --git a/common/chequebook/cheque_test.go b/common/chequebook/cheque_test.go new file mode 100644 index 0000000000..06d95ff380 --- /dev/null +++ b/common/chequebook/cheque_test.go @@ -0,0 +1,498 @@ +package chequebook + +import ( + "math/big" + "testing" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" +) + +type testBackend struct { + calls []string + errs []error + txs []string +} + +func newTestBackend() *testBackend { + return &testBackend{} +} + +func (b *testBackend) Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) { + txhash := string(crypto.Sha3([]byte(codeStr))) + b.txs = append(b.txs, txhash) + return txhash, nil +} + +func (b *testBackend) Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, string, error) { + if len(b.calls) == 0 { + panic("test backend called too many times") + } + res := b.calls[0] + err := b.errs[0] + b.calls = b.calls[1:] + b.errs = b.errs[1:] + return res, "", err +} + +func (b *testBackend) GetTxReceipt(txhash common.Hash) *types.Receipt { + return nil +} + +func (b *testBackend) CodeAt(address string) string { + return "" +} + +func genAddr() common.Address { + prvKey, _ := crypto.GenerateKey() + return crypto.PubkeyToAddress(prvKey.PublicKey) +} + +func TestIssueAndReceive(t *testing.T) { + prvKey, _ := crypto.GenerateKey() + sender := genAddr() + path := "/tmp/checkbook.json" + chbook, err := NewChequebook(path, sender, prvKey, nil) + if err != nil { + t.Errorf("expected no error, got %v", err) + } + recipient := genAddr() + chbook.sent[recipient] = new(big.Int).SetUint64(42) + amount := common.Big1 + ch, err := chbook.Issue(recipient, amount) + if err == nil { + t.Errorf("expected insufficient funds error, got none") + } + + chbook.balance = new(big.Int).Set(common.Big1) + if chbook.Balance().Cmp(common.Big1) != 0 { + t.Errorf("expected: %v, got %v", "0", chbook.Balance()) + } + + ch, err = chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + if chbook.Balance().Cmp(common.Big0) != 0 { + t.Errorf("expected: %v, got %v", "0", chbook.Balance()) + } + + backend := newTestBackend() + backend.calls = []string{common.ToHex(big.NewInt(42).Bytes())} + backend.errs = []error{nil} + chbox, err := NewInbox(sender, recipient, recipient, &prvKey.PublicKey, backend) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + received, err := chbox.Receive(ch) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + if received.Cmp(common.Big1) != 0 { + t.Errorf("expected: %v, got %v", "1", received) + } + +} + +func TestCheckbookFile(t *testing.T) { + prvKey, _ := crypto.GenerateKey() + sender := genAddr() + path := "/tmp/checkbook.json" + chbook, err := NewChequebook(path, sender, prvKey, nil) + if err != nil { + t.Errorf("expected no error, got %v", err) + } + recipient := genAddr() + chbook.sent[recipient] = new(big.Int).SetUint64(42) + chbook.balance = new(big.Int).Set(common.Big1) + + chbook.Save() + + chbook, err = LoadChequebook(path, prvKey, nil) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + if chbook.Balance().Cmp(common.Big1) != 0 { + t.Errorf("expected: %v, got %v", "0", chbook.Balance()) + } + + ch, err := chbook.Issue(recipient, common.Big1) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + if ch.Amount.Cmp(new(big.Int).SetUint64(43)) != 0 { + t.Errorf("expected: %v, got %v", "0", ch.Amount) + } + + err = chbook.Save() + if err != nil { + t.Fatalf("expected no error, got %v", err) + } +} + +func TestVerifyErrors(t *testing.T) { + prvKey, _ := crypto.GenerateKey() + sender0 := genAddr() + sender1 := genAddr() + path0 := "/tmp/checkbook0.json" + chbook0, err := NewChequebook(path0, sender0, prvKey, nil) + if err != nil { + t.Errorf("expected no error, got %v", err) + } + path1 := "/tmp/checkbook1.json" + chbook1, err := NewChequebook(path1, sender1, prvKey, nil) + if err != nil { + t.Errorf("expected no error, got %v", err) + } + recipient0 := genAddr() + recipient1 := genAddr() + chbook0.balance = new(big.Int).Set(common.Big2) + chbook1.balance = new(big.Int).Set(common.Big1) + chbook0.sent[recipient0] = new(big.Int).SetUint64(42) + amount := common.Big1 + ch0, err := chbook0.Issue(recipient0, amount) + + backend := newTestBackend() + backend.calls = []string{common.ToHex(big.NewInt(42).Bytes())} + backend.errs = []error{nil} + chbox, err := NewInbox(sender0, recipient0, recipient0, &prvKey.PublicKey, backend) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + received, err := chbox.Receive(ch0) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + if received.Cmp(common.Big1) != 0 { + t.Errorf("expected: %v, got %v", "1", received) + } + + ch1, err := chbook0.Issue(recipient1, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + received, err = chbox.Receive(ch1) + t.Log(err) + if err == nil { + t.Fatalf("expected receiver error, got none") + } + + ch2, err := chbook1.Issue(recipient0, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + received, err = chbox.Receive(ch2) + t.Log(err) + if err == nil { + t.Fatalf("expected sender error, got none") + } + + _, err = chbook1.Issue(recipient0, new(big.Int).SetInt64(-1)) + t.Log(err) + if err == nil { + t.Fatalf("expected incorrect amount error, got none") + } + + received, err = chbox.Receive(ch0) + t.Log(err) + if err == nil { + t.Fatalf("expected incorrect amount error, got none") + } + +} + +func TestDeposit(t *testing.T) { + prvKey, _ := crypto.GenerateKey() + sender := genAddr() + path := "/tmp/checkbook.json" + + backend := newTestBackend() + chbook, err := NewChequebook(path, sender, prvKey, backend) + if err != nil { + t.Errorf("expected no error, got %v", err) + } + + balance := new(big.Int).SetUint64(42) + chbook.Deposit(balance) + if len(backend.txs) != 1 { + t.Fatalf("expected 1 txs to send, got %v", len(backend.txs)) + } + if chbook.balance.Cmp(balance) != 0 { + t.Fatalf("expected balance %v, got %v", balance, chbook.balance) + } + + recipient := genAddr() + amount := common.Big1 + _, err = chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + exp := new(big.Int).SetUint64(41) + if chbook.balance.Cmp(exp) != 0 { + t.Fatalf("expected balance %v, got %v", exp, chbook.balance) + } + + // autodeposit on each issue + chbook.AutoDeposit(0, balance, balance) + _, err = chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + _, err = chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + if len(backend.txs) != 3 { + t.Fatalf("expected 3 txs to send, got %v", len(backend.txs)) + } + if chbook.balance.Cmp(balance) != 0 { + t.Fatalf("expected balance %v, got %v", balance, chbook.balance) + } + + // autodeposit off + chbook.AutoDeposit(0, common.Big0, balance) + _, err = chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + _, err = chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + if len(backend.txs) != 3 { + t.Fatalf("expected 3 txs to send, got %v", len(backend.txs)) + } + exp = new(big.Int).SetUint64(40) + if chbook.balance.Cmp(exp) != 0 { + t.Fatalf("expected balance %v, got %v", exp, chbook.balance) + } + + // autodeposit every 10ms if new cheque issued + interval := 30 * time.Millisecond + chbook.AutoDeposit(interval, common.Big1, balance) + _, err = chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + _, err = chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + if len(backend.txs) != 3 { + t.Fatalf("expected 3 txs to send, got %v", len(backend.txs)) + } + exp = new(big.Int).SetUint64(38) + if chbook.balance.Cmp(exp) != 0 { + t.Fatalf("expected balance %v, got %v", exp, chbook.balance) + } + + time.Sleep(3 * interval) + if len(backend.txs) != 4 { + t.Fatalf("expected 4 txs to send, got %v", len(backend.txs)) + } + if chbook.balance.Cmp(balance) != 0 { + t.Fatalf("expected balance %v, got %v", balance, chbook.balance) + } + + exp = new(big.Int).SetUint64(40) + chbook.AutoDeposit(4*interval, exp, balance) + _, err = chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + _, err = chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + time.Sleep(3 * interval) + if len(backend.txs) != 4 { + t.Fatalf("expected 4 txs to send, got %v", len(backend.txs)) + } + if chbook.balance.Cmp(exp) != 0 { + t.Fatalf("expected balance %v, got %v", exp, chbook.balance) + } + + _, err = chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + time.Sleep(1 * interval) + + if len(backend.txs) != 5 { + t.Fatalf("expected 5 txs to send, got %v", len(backend.txs)) + } + if chbook.balance.Cmp(balance) != 0 { + t.Fatalf("expected balance %v, got %v", balance, chbook.balance) + } + + chbook.AutoDeposit(1*interval, common.Big0, balance) + chbook.Stop() + + _, err = chbook.Issue(recipient, common.Big1) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + _, err = chbook.Issue(recipient, common.Big2) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + time.Sleep(1 * interval) + + if len(backend.txs) != 5 { + t.Fatalf("expected 5 txs to send, got %v", len(backend.txs)) + } + exp = new(big.Int).SetUint64(39) + if chbook.balance.Cmp(exp) != 0 { + t.Fatalf("expected balance %v, got %v", exp, chbook.balance) + } + +} + +func TestCash(t *testing.T) { + prvKey, _ := crypto.GenerateKey() + sender := genAddr() + path := "/tmp/checkbook.json" + chbook, err := NewChequebook(path, sender, prvKey, nil) + if err != nil { + t.Errorf("expected no error, got %v", err) + } + recipient := genAddr() + chbook.sent[recipient] = new(big.Int).SetUint64(42) + amount := common.Big1 + chbook.balance = new(big.Int).Set(common.Big1) + ch, err := chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + backend := newTestBackend() + backend.calls = []string{common.ToHex(big.NewInt(42).Bytes())} + backend.errs = []error{nil} + chbox, err := NewInbox(sender, recipient, recipient, &prvKey.PublicKey, backend) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + // cashing latest cheque + _, err = chbox.Receive(ch) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + _, err = ch.Cash(recipient, backend) + if len(backend.txs) != 1 { + t.Fatalf("expected 1 txs to send, got %v", len(backend.txs)) + } + + chbook.balance = new(big.Int).Set(common.Big3) + ch0, err := chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + ch1, err := chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + interval := 10 * time.Millisecond + // setting autocash with interval of 10ms + chbox.AutoCash(interval, nil) + _, err = chbox.Receive(ch0) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + _, err = chbox.Receive(ch1) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + // after < interval time and 2 cheques received, no new cashing tx is sent + if len(backend.txs) != 1 { + t.Fatalf("expected 1 txs to send, got %v", len(backend.txs)) + } + // after 3x interval time and 2 cheques received, exactly one cashing tx is sent + time.Sleep(4 * interval) + if len(backend.txs) != 2 { + t.Fatalf("expected 2 txs to send, got %v", len(backend.txs)) + } + + // after stopping autocash no more tx are sent + ch2, err := chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + chbox.Stop() + time.Sleep(interval) // make sure loop stops + _, err = chbox.Receive(ch2) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + time.Sleep(2 * interval) + if len(backend.txs) != 2 { + t.Fatalf("expected 2 txs to send, got %v", len(backend.txs)) + } + + // autocash below 1 + chbook.balance = new(big.Int).Set(common.Big2) + chbox.AutoCash(0, common.Big1) + + ch3, err := chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + ch4, err := chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + _, err = chbox.Receive(ch3) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + _, err = chbox.Receive(ch4) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + // 2 checks of amount 1 received, exactly 1 tx is sent + if len(backend.txs) != 3 { + t.Fatalf("expected 3 txs to send, got %v", len(backend.txs)) + } + + // autochash on receipt when maxUncashed is 0 + chbook.balance = new(big.Int).Set(common.Big2) + chbox.AutoCash(0, common.Big0) + + ch5, err := chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + ch6, err := chbook.Issue(recipient, amount) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + _, err = chbox.Receive(ch5) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + _, err = chbox.Receive(ch6) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + + if len(backend.txs) != 5 { + t.Fatalf("expected 5 txs to send, got %v", len(backend.txs)) + } + +} diff --git a/common/chequebook/chequebook.sol b/common/chequebook/chequebook.sol new file mode 100644 index 0000000000..836d570472 --- /dev/null +++ b/common/chequebook/chequebook.sol @@ -0,0 +1,49 @@ +import "mortal"; + +/// @title Chequebook for Ethereum micropayments +/// @author Daniel A. Nagy +contract chequebook is mortal { + // Cumulative paid amount in wei to each beneficiary + mapping (address => uint256) sent; + + /// @notice Overdraft event + event Overdraft(address deadbeat); + + /// @notice Accessor for sent map + /// + /// @param beneficiary beneficiary address + /// @return cumulative amount in wei sent to beneficiary + function getSent(address beneficiary) constant returns (uint256) { + return sent[beneficiary]; + } + + /// @notice Cash cheque + /// + /// @param beneficiary beneficiary address + /// @param amount cumulative amount in wei + /// @param sig_v signature parameter v + /// @param sig_r signature parameter r + /// @param sig_s signature parameter s + /// The digital signature is calculated on the concatenated triplet of contract address, beneficiary address and cumulative amount + function cash(address beneficiary, uint256 amount, + uint8 sig_v, bytes32 sig_r, bytes32 sig_s) { + // Check if the cheque is old. + // Only cheques that are more recent than the last cashed one are considered. + if(amount <= sent[beneficiary]) return; + // Check the digital signature of the cheque. + bytes32 hash = sha3(address(this), beneficiary, amount); + if(owner != ecrecover(hash, sig_v, sig_r, sig_s)) return; + // Attempt sending the difference between the cumulative amount on the cheque + // and the cumulative amount on the last cashed cheque to beneficiary. + if (beneficiary.send(amount - sent[beneficiary])) { + // Upon success, update the cumulative amount. + sent[beneficiary] = amount; + } else { + // Upon failure, punish owner for writing a bounced cheque. + // owner.sendToDebtorsPrison(); + Overdraft(owner); + // Compensate beneficiary. + suicide(beneficiary); + } + } +} diff --git a/common/chequebook/contract.go b/common/chequebook/contract.go new file mode 100644 index 0000000000..866d7c3358 --- /dev/null +++ b/common/chequebook/contract.go @@ -0,0 +1,63 @@ +package chequebook + +import () + +const ( + ContractCode = `606060405260008054600160a060020a03191633179055610201806100246000396000f3606060405260e060020a600035046341c0e1b58114610031578063d75d691d14610059578063fbf788d61461007e575b005b61002f60005433600160a060020a03908116911614156101ff57600054600160a060020a0316ff5b600160a060020a03600435166000908152600160205260409020546060908152602090f35b61002f600435602435604435606435608435600160a060020a03851660009081526001602052604081205485116100b8575b505050505050565b30600160a060020a039081166c0100000000000000000000000090810260609081529188160260745260888690526048812080825260ff8616608090815260a086905260c0859052909260019260e0926020928290866161da5a03f11561000257505060405151600054600160a060020a03908116911614610139576100b0565b85600160a060020a031660006001600050600089600160a060020a03168152602001908152602001600020600050548703604051809050600060405180830381858888f19350505050156101b357846001600050600088600160a060020a03168152602001908152602001600020600050819055506100b0565b60005460408051600160a060020a03929092168252517f2250e2993c15843b32621c89447cc589ee7a9f049c026986e545d3c2c0c6f9789181900360200190a185600160a060020a0316ff5b56` + + ContractDeployedCode = `0x606060405260e060020a600035046341c0e1b58114610031578063d75d691d14610059578063fbf788d61461007e575b005b61002f60005433600160a060020a03908116911614156101ff57600054600160a060020a0316ff5b600160a060020a03600435166000908152600160205260409020546060908152602090f35b61002f600435602435604435606435608435600160a060020a03851660009081526001602052604081205485116100b8575b505050505050565b30600160a060020a039081166c0100000000000000000000000090810260609081529188160260745260888690526048812080825260ff8616608090815260a086905260c0859052909260019260e0926020928290866161da5a03f11561000257505060405151600054600160a060020a03908116911614610139576100b0565b85600160a060020a031660006001600050600089600160a060020a03168152602001908152602001600020600050548703604051809050600060405180830381858888f19350505050156101b357846001600050600088600160a060020a03168152602001908152602001600020600050819055506100b0565b60005460408051600160a060020a03929092168252517f2250e2993c15843b32621c89447cc589ee7a9f049c026986e545d3c2c0c6f9789181900360200190a185600160a060020a0316ff5b56` + + ContractAbi = `[{"constant":false,"inputs":[],"name":"kill","outputs":[],"type":"function"},{"constant":true,"inputs":[{"name":"beneficiary","type":"address"}],"name":"getSent","outputs":[{"name":"","type":"uint256"}],"type":"function"},{"constant":false,"inputs":[{"name":"beneficiary","type":"address"},{"name":"amount","type":"uint256"},{"name":"sig_v","type":"uint8"},{"name":"sig_r","type":"bytes32"},{"name":"sig_s","type":"bytes32"}],"name":"cash","outputs":[],"type":"function"},{"anonymous":false,"inputs":[{"indexed":false,"name":"deadbeat","type":"address"}],"name":"Overdraft","type":"event"}]` + + ContractSource = ` +import "mortal"; + +/// @title Chequebook for Ethereum micropayments +/// @author Daniel A. Nagy +contract chequebook is mortal { + // Cumulative paid amount in wei to each beneficiary + mapping (address => uint256) sent; + + /// @notice Overdraft event + event Overdraft(address deadbeat); + + /// @notice Accessor for sent map + /// + /// @param beneficiary beneficiary address + /// @return cumulative amount in wei sent to beneficiary + function getSent(address beneficiary) returns (uint256) { + return sent[beneficiary]; + } + + /// @notice Cash cheque + /// + /// @param beneficiary beneficiary address + /// @param amount cumulative amount in wei + /// @param sig_v signature parameter v + /// @param sig_r signature parameter r + /// @param sig_s signature parameter s + /// The digital signature is calculated on the concatenated triplet of contract address, beneficiary address and cumulative amount + function cash(address beneficiary, uint256 amount, + uint8 sig_v, bytes32 sig_r, bytes32 sig_s) { + // Check if the cheque is old. + // Only cheques that are more recent than the last cashed one are considered. + if(amount <= sent[beneficiary]) return; + // Check the digital signature of the cheque. + bytes32 hash = sha3(address(this), beneficiary, amount); + if(owner != ecrecover(hash, sig_v, sig_r, sig_s)) return; + // Attempt sending the difference between the cumulative amount on the cheque + // and the cumulative amount on the last cashed cheque to beneficiary. + if (beneficiary.send(amount - sent[beneficiary])) { + // Upon success, update the cumulative amount. + sent[beneficiary] = amount; + } else { + // Upon failure, punish owner for writing a bounced cheque. + // owner.sendToDebtorsPrison(); + Overdraft(owner); + // Compensate beneficiary. + suicide(beneficiary); + } + } +} +` +) diff --git a/common/kademlia/address.go b/common/kademlia/address.go new file mode 100644 index 0000000000..a6ce4e4770 --- /dev/null +++ b/common/kademlia/address.go @@ -0,0 +1,157 @@ +package kademlia + +import ( + "fmt" + "math/rand" + "strings" + + "github.com/ethereum/go-ethereum/common" +) + +type Address common.Hash + +func (a Address) String() string { + return fmt.Sprintf("%x", a[:]) +} + +func (a *Address) MarshalJSON() (out []byte, err error) { + return []byte(`"` + a.String() + `"`), nil +} + +func (a *Address) UnmarshalJSON(value []byte) error { + *a = Address(common.HexToHash(string(value[1 : len(value)-1]))) + return nil +} + +// the string form of the binary representation of an address (only first 8 bits) +func (a Address) Bin() string { + var bs []string + for _, b := range a[:] { + bs = append(bs, fmt.Sprintf("%08b", b)) + } + return strings.Join(bs, "") +} + +/* +Proximity(x, y) returns the proximity order of the MSB distance between x and y + +The distance metric MSB(x, y) of two equal length byte sequences x an y is the +value of the binary integer cast of the x^y, ie., x and y bitwise xor-ed. +the binary cast is big endian: most significant bit first (=MSB). + +Proximity(x, y) is a discrete logarithmic scaling of the MSB distance. +It is defined as the reverse rank of the integer part of the base 2 +logarithm of the distance. +It is calculated by counting the number of common leading zeros in the (MSB) +binary representation of the x^y. + +(0 farthest, 255 closest, 256 self) +*/ +func proximity(one, other Address) (ret int) { + for i := 0; i < len(one); i++ { + oxo := one[i] ^ other[i] + for j := 0; j < 8; j++ { + if (uint8(oxo)>>uint8(7-j))&0x01 != 0 { + return i*8 + j + } + } + } + return len(one) * 8 +} + +// Address.ProxCmp compares the distances a->target and b->target. +// Returns -1 if a is closer to target, 1 if b is closer to target +// and 0 if they are equal. +func (target Address) ProxCmp(a, b Address) int { + for i := range target { + da := a[i] ^ target[i] + db := b[i] ^ target[i] + if da > db { + return 1 + } else if da < db { + return -1 + } + } + return 0 +} + +// randomAddressAt(address, prox) generates a random address +// at proximity order prox relative to address +// if prox is negative a random address is generated +func RandomAddressAt(self Address, prox int) (addr Address) { + addr = self + var pos int + if prox >= 0 { + pos = prox / 8 + trans := prox % 8 + transbytea := byte(0) + for j := 0; j <= trans; j++ { + transbytea |= 1 << uint8(7-j) + } + flipbyte := byte(1 << uint8(7-trans)) + transbyteb := transbytea ^ byte(255) + randbyte := byte(rand.Intn(255)) + addr[pos] = ((addr[pos] & transbytea) ^ flipbyte) | randbyte&transbyteb + } + for i := pos + 1; i < len(addr); i++ { + addr[i] = byte(rand.Intn(255)) + } + + return +} + +// KeyRange(a0, a1, proxLimit) returns the address inclusive address +// range that contain addresses closer to one than other +func KeyRange(one, other Address, proxLimit int) (start, stop Address) { + prox := proximity(one, other) + if prox >= proxLimit { + prox = proxLimit + } + start = CommonBitsAddrByte(one, other, byte(0x00), prox) + stop = CommonBitsAddrByte(one, other, byte(0xff), prox) + return +} + +func CommonBitsAddrF(self, other Address, f func() byte, p int) (addr Address) { + prox := proximity(self, other) + var pos int + if p <= prox { + prox = p + } + pos = prox / 8 + addr = self + trans := byte(prox % 8) + var transbytea byte + if p > prox { + transbytea = byte(0x7f) + } else { + transbytea = byte(0xff) + } + transbytea >>= trans + transbyteb := transbytea ^ byte(0xff) + addrpos := addr[pos] + addrpos &= transbyteb + if p > prox { + addrpos ^= byte(0x80 >> trans) + } + addrpos |= transbytea & f() + addr[pos] = addrpos + for i := pos + 1; i < len(addr); i++ { + addr[i] = f() + } + + return +} + +func CommonBitsAddr(self, other Address, prox int) (addr Address) { + return CommonBitsAddrF(self, other, func() byte { return byte(rand.Intn(255)) }, prox) +} + +func CommonBitsAddrByte(self, other Address, b byte, prox int) (addr Address) { + return CommonBitsAddrF(self, other, func() byte { return b }, prox) +} + +// randomAddressAt() generates a random address +func RandomAddress() Address { + return RandomAddressAt(Address{}, -1) +} diff --git a/common/kademlia/address_test.go b/common/kademlia/address_test.go new file mode 100644 index 0000000000..b0577dc243 --- /dev/null +++ b/common/kademlia/address_test.go @@ -0,0 +1,80 @@ +package kademlia + +import ( + "math/rand" + "reflect" + "testing" + + "github.com/ethereum/go-ethereum/common" +) + +func (Address) Generate(rand *rand.Rand, size int) reflect.Value { + var id Address + for i := 0; i < len(id); i++ { + id[i] = byte(uint8(rand.Intn(255))) + } + return reflect.ValueOf(id) +} + +func TestCommonBitsAddrF(t *testing.T) { + a := Address(common.HexToHash("0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef")) + b := Address(common.HexToHash("0x8123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef")) + c := Address(common.HexToHash("0x4123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef")) + d := Address(common.HexToHash("0x0023456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef")) + e := Address(common.HexToHash("0x01A3456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef")) + ab := CommonBitsAddrF(a, b, func() byte { return byte(0x00) }, 10) + expab := Address(common.HexToHash("0x8000000000000000000000000000000000000000000000000000000000000000")) + + if ab != expab { + t.Fatalf("%v != %v", ab, expab) + } + ac := CommonBitsAddrF(a, c, func() byte { return byte(0x00) }, 10) + expac := Address(common.HexToHash("0x4000000000000000000000000000000000000000000000000000000000000000")) + + if ac != expac { + t.Fatalf("%v != %v", ac, expac) + } + ad := CommonBitsAddrF(a, d, func() byte { return byte(0x00) }, 10) + expad := Address(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000")) + + if ad != expad { + t.Fatalf("%v != %v", ad, expad) + } + ae := CommonBitsAddrF(a, e, func() byte { return byte(0x00) }, 10) + expae := Address(common.HexToHash("0x0180000000000000000000000000000000000000000000000000000000000000")) + + if ae != expae { + t.Fatalf("%v != %v", ae, expae) + } + acf := CommonBitsAddrF(a, c, func() byte { return byte(0xff) }, 10) + expacf := Address(common.HexToHash("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + + if acf != expacf { + t.Fatalf("%v != %v", acf, expacf) + } + aeo := CommonBitsAddrF(a, e, func() byte { return byte(0x00) }, 2) + expaeo := Address(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000000")) + + if aeo != expaeo { + t.Fatalf("%v != %v", aeo, expaeo) + } + aep := CommonBitsAddrF(a, e, func() byte { return byte(0xff) }, 2) + expaep := Address(common.HexToHash("0x3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")) + + if aep != expaep { + t.Fatalf("%v != %v", aep, expaep) + } + +} + +func TestRandomAddressAt(t *testing.T) { + var a Address + for i := 0; i < 100; i++ { + a = RandomAddress() + prox := rand.Intn(255) + b := RandomAddressAt(a, prox) + if proximity(a, b) != prox { + t.Fatalf("incorrect address prox(%v, %v) == %v (expected %v)", a, b, proximity(a, b), prox) + } + } +} diff --git a/common/kademlia/kaddb.go b/common/kademlia/kaddb.go new file mode 100644 index 0000000000..e45a9dc48e --- /dev/null +++ b/common/kademlia/kaddb.go @@ -0,0 +1,360 @@ +package kademlia + +import ( + "encoding/json" + "fmt" + "io/ioutil" + "os" + "sync" + "time" + + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/logger/glog" +) + +type Time time.Time + +func (t *Time) MarshalJSON() (out []byte, err error) { + return []byte(fmt.Sprintf("%d", t.Unix())), nil +} + +func (t *Time) UnmarshalJSON(value []byte) error { + var i int64 + _, err := fmt.Sscanf(string(value), "%d", &i) + if err != nil { + return err + } + *t = Time(time.Unix(i, 0)) + return nil +} + +func (t Time) Unix() int64 { + return time.Time(t).Unix() +} + +type NodeData interface { + json.Marshaler + json.Unmarshaler +} + +// allow inactive peers under +type NodeRecord struct { + Addr Address // address of node + Url string // Url, used to connect to node + After Time // next call after time + Seen Time // last connected at time + Meta *json.RawMessage // arbitrary metadata saved for a peer + + node Node + connected bool +} + +// set checked to current time, +func (self *NodeRecord) setSeen() { + self.Seen = Time(time.Now()) +} + +func (self *NodeRecord) String() string { + return fmt.Sprintf("<%v>", self.Addr) +} + +// persisted node record database () +type KadDb struct { + Address Address + Nodes [][]*NodeRecord + index map[Address]*NodeRecord + cursors []int + lock sync.Mutex + purgeInterval time.Duration + initialRetryInterval time.Duration + connRetryExp int +} + +func newKadDb(addr Address, params *KadParams) *KadDb { + return &KadDb{ + Address: addr, + Nodes: make([][]*NodeRecord, params.MaxProx+1), // overwritten by load + cursors: make([]int, params.MaxProx+1), + index: make(map[Address]*NodeRecord), + purgeInterval: params.PurgeInterval, + initialRetryInterval: params.InitialRetryInterval, + connRetryExp: params.ConnRetryExp, + } +} + +func (self *KadDb) findOrCreate(index int, a Address, url string) *NodeRecord { + defer self.lock.Unlock() + self.lock.Lock() + + record, found := self.index[a] + if !found { + record = &NodeRecord{ + Addr: a, + Url: url, + } + glog.V(logger.Info).Infof("[KΛÐ]: add new record %v to kaddb", record) + // insert in kaddb + self.index[a] = record + self.Nodes[index] = append(self.Nodes[index], record) + } else { + glog.V(logger.Info).Infof("[KΛÐ]: found record %v in kaddb", record) + } + // update last seen time + record.setSeen() + // update with url in case IP/port changes + record.Url = url + return record +} + +// add adds node records to kaddb (persisted node record db) +func (self *KadDb) add(nrs []*NodeRecord, proximityBin func(Address) int) { + defer self.lock.Unlock() + self.lock.Lock() + var n int + var nodes []*NodeRecord + for _, node := range nrs { + _, found := self.index[node.Addr] + if !found && node.Addr != self.Address { + node.setSeen() + self.index[node.Addr] = node + index := proximityBin(node.Addr) + dbcursor := self.cursors[index] + nodes = self.Nodes[index] + // this is inefficient for allocation, need to just append then shift + newnodes := make([]*NodeRecord, len(nodes)+1) + copy(newnodes[:], nodes[:dbcursor]) + newnodes[dbcursor] = node + copy(newnodes[dbcursor+1:], nodes[dbcursor:]) + glog.V(logger.Detail).Infof("[KΛÐ]: new nodes: %v (keys: %v)\nnodes: %v", newnodes, nodes) + self.Nodes[index] = newnodes + n++ + } + } + glog.V(logger.Detail).Infof("[KΛÐ]: received %d node records, added %d new", len(nrs), n) +} + +/* +next return one node record with the highest priority for desired +connection. +This is used to pick candidates for live nodes that are most wanted for +a higly connected low centrality network structure for Swarm which best suits +for a Kademlia-style routing. + +The candidate is chosen using the following strategy. +We check for missing online nodes in the buckets for 1 upto Max BucketSize rounds. +On each round we proceed from the low to high proximity order buckets. +If the number of active nodes (=connected peers) is < rounds, then start looking +for a known candidate. To determine if there is a candidate to recommend the +node record database row corresponding to the bucket is checked.a +If the row cursor is on position i, the ith element in the row is chosen. +If the record is scheduled not to be retried before NOW, the next element is taken. +If the record is scheduled can be retried, it is set as checked, scheduled for +checking and is returned. The time of the next check is in X (duration) such that +X = ConnRetryExp * delta where delta is the time past since the last check and +ConnRetryExp is constant obsoletion factor. (Note that when node records are added +from peer messages, they are marked as checked and placed at the cursor, ie. +given priority over older entries). Entries which were checked more than +purgeInterval ago are deleted from the kaddb row. If no candidate is found after +a full round of checking the next bucket up is considered. If no candidate is +found when we reach the maximum-proximity bucket, the next round starts. + +node record a is more favoured to b a > b iff a is a passive node (record of +offline past peer) +|proxBin(a)| < |proxBin(b)| +|| (proxBin(a) < proxBin(b) && |proxBin(a)| == |proxBin(b)|) +|| (proxBin(a) == proxBin(b) && lastChecked(a) < lastChecked(b)) + +This has double role. Starting as naive node with empty db, this implements +Kademlia bootstrapping +As a mature node, it fills short lines. All on demand. + +The second argument returned names the first missing slot found +*/ +func (self *KadDb) findBest(bucketSize int, binsize func(int) int) (node *NodeRecord, proxLimit int) { + // return value -1 indicates that buckets are filled in all + proxLimit = -1 + defer self.lock.Unlock() + self.lock.Lock() + + var interval int64 + var found bool + for rounds := 1; rounds <= bucketSize; rounds++ { + ROUND: + for po, dbrow := range self.Nodes { + if po > len(self.Nodes) { + break ROUND + } + size := binsize(po) + if size < rounds { + if proxLimit < 0 { + // set the first missing slot found + proxLimit = po + } + var count int + var purge []int + n := self.cursors[po] + + // try node records in the relavant kaddb row (of identical prox order) + // if they are ripe for checking + ROW: + for count < len(dbrow) { + node = dbrow[n] + + // skip already connected nodes + if !node.connected { + + glog.V(logger.Detail).Infof("[KΛÐ]: kaddb record %v (PO%03d:%d) not to be retried before %v", node.Addr, po, n, node.After) + + // time since last known connection attempt + delta := node.After.Unix() - node.Seen.Unix() + // if delta < 4 { + // node.After = Time(time.Time{}) + // } + + // if node is scheduled to connect + if time.Time(node.After).Before(time.Now()) { + + // if checked longer than purge interval + if time.Time(node.Seen).Add(self.purgeInterval).Before(time.Now()) { + // delete node + purge = append(purge, n) + glog.V(logger.Detail).Infof("[KΛÐ]: inactive node record %v (PO%03d:%d) last check: %v, next check: %v", node.Addr, po, n, node.Seen, node.After) + } else { + // scheduling next check + if (node.After == Time(time.Time{})) { + node.After = Time(time.Now().Add(self.initialRetryInterval)) + } else { + interval = delta * int64(self.connRetryExp) + node.After = Time(time.Unix(time.Now().Unix()+interval, 0)) + } + + glog.V(logger.Detail).Infof("[KΛÐ]: serve node record %v (PO%03d:%d), last check: %v, next check: %v", node.Addr, po, n, node.Seen, node.After) + } + found = true + break ROW + } + glog.V(logger.Detail).Infof("[KΛÐ]: kaddb record %v (PO%03d:%d) not ready. skipped. not to be retried before: %v", node.Addr, po, n, node.After) + } // if node.node == nil + n++ + count++ + // cycle: n = n % len(dbrow) + if n >= len(dbrow) { + n = 0 + } + } + self.cursors[po] = n + self.delete(po, purge...) + if found { + glog.V(logger.Detail).Infof("[KΛÐ]: rounds %d: prox limit: PO%03d\n%v", rounds, proxLimit, node) + node.setSeen() + return + } + } // if len < rounds + } // for po-s + glog.V(logger.Detail).Infof("[KΛÐ]: rounds %d: proxlimit: PO%03d", rounds, proxLimit) + if proxLimit == 0 || proxLimit < 0 && bucketSize == rounds { + return + } + } // for round + + return +} + +// deletes the noderecords of a kaddb row corresponding to the indexes +// caller must hold the dblock +// the call is unsafe, no index checks +func (self *KadDb) delete(row int, indexes ...int) { + var prev int + var nodes []*NodeRecord + dbrow := self.Nodes[row] + for _, next := range indexes { + // need to adjust dbcursor + if next > 0 { + if next <= self.cursors[row] { + self.cursors[row]-- + } + nodes = append(nodes, dbrow[prev:next]...) + } + prev = next + 1 + delete(self.index, dbrow[next].Addr) + } + self.Nodes[row] = append(nodes, dbrow[prev:]...) +} + +// save persists kaddb on disk (written to file on path in json format. +func (self *KadDb) save(path string, cb func(*NodeRecord, Node)) error { + defer self.lock.Unlock() + self.lock.Lock() + + var n int + + for _, b := range self.Nodes { + for _, node := range b { + n++ + node.After = Time(time.Now()) + node.Seen = Time(time.Now()) + if cb != nil { + cb(node, node.node) + } + } + } + + data, err := json.MarshalIndent(self, "", " ") + if err != nil { + return err + } + err = ioutil.WriteFile(path, data, os.ModePerm) + if err != nil { + glog.V(logger.Warn).Infof("[KΛÐ]: unable to save kaddb with %v nodes to %v: err", n, path, err) + } else { + glog.V(logger.Info).Infof("[KΛÐ] saved kaddb with %v nodes to %v", n, path) + } + return err +} + +// Load(path) loads the node record database (kaddb) from file on path. +func (self *KadDb) load(path string, cb func(*NodeRecord, Node) error) (err error) { + defer self.lock.Unlock() + self.lock.Lock() + + var data []byte + data, err = ioutil.ReadFile(path) + if err != nil { + return + } + + err = json.Unmarshal(data, self) + if err != nil { + return + } + var n int + var purge []int + for po, b := range self.Nodes { + ROW: + for i, node := range b { + if cb != nil { + err = cb(node, node.node) + if err != nil { + purge = append(purge, i) + continue ROW + } + } + n++ + if (node.After == Time(time.Time{})) { + node.After = Time(time.Now()) + } + self.index[node.Addr] = node + } + self.delete(po, purge...) + } + glog.V(logger.Info).Infof("[KΛÐ] loaded kaddb with %v nodes from %v", n, path) + + return +} + +// accessor for KAD offline db count +func (self *KadDb) count() int { + defer self.lock.Unlock() + self.lock.Lock() + return len(self.index) +} diff --git a/common/kademlia/kademlia.go b/common/kademlia/kademlia.go new file mode 100644 index 0000000000..ac80e8b406 --- /dev/null +++ b/common/kademlia/kademlia.go @@ -0,0 +1,457 @@ +package kademlia + +import ( + "fmt" + "sort" + "strings" + "sync" + "time" + + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/logger/glog" +) + +const ( + bucketSize = 20 + maxProx = 255 + connRetryExp = 2 +) + +var ( + purgeInterval = 42 * time.Hour + initialRetryInterval = 42 * 100 * time.Millisecond +) + +type KadParams struct { + // adjustable parameters + MaxProx int + ProxBinSize int + BucketSize int + PurgeInterval time.Duration + InitialRetryInterval time.Duration + ConnRetryExp int +} + +func NewKadParams() *KadParams { + return &KadParams{ + MaxProx: maxProx, + ProxBinSize: bucketSize, + BucketSize: bucketSize, + PurgeInterval: purgeInterval, + InitialRetryInterval: initialRetryInterval, + ConnRetryExp: connRetryExp, + } +} + +// Kademlia is a table of active nodes +type Kademlia struct { + addr Address // immutable baseaddress of the table + *KadParams // Kademlia configuration parameters + proxLimit int // state, the PO of the first row of the most proximate bin + proxSize int // state, the number of peers in the most proximate bin + count int // number of active peers (w live connection) + buckets []*bucket // the actual bins + db *KadDb // kaddb, node record database + lock sync.RWMutex // mutex to access buckets +} + +type Node interface { + Addr() Address + Url() string + LastActive() time.Time + Drop() +} + +// public constructor +// add is the base address of the table +// params is KadParams configuration +func New(addr Address, params *KadParams) *Kademlia { + buckets := make([]*bucket, params.MaxProx+1) + for i, _ := range buckets { + buckets[i] = &bucket{size: params.BucketSize} // will initialise bucket{int(0),[]Node(nil),sync.Mutex} + } + glog.V(logger.Info).Infof("[KΛÐ] base address %v", addr) + + return &Kademlia{ + addr: addr, + KadParams: params, + buckets: buckets, + db: newKadDb(addr, params), + } +} + +// accessor for KAD base address +func (self *Kademlia) Addr() Address { + return self.addr +} + +// accessor for KAD active node count +func (self *Kademlia) Count() int { + defer self.lock.Unlock() + self.lock.Lock() + return self.count +} + +// accessor for KAD active node count +func (self *Kademlia) DBCount() int { + return self.db.count() +} + +// On is the entry point called when a new nodes is added +// unsafe in that node is not checked to be already active node (to be called once) +func (self *Kademlia) On(node Node, cb func(*NodeRecord, Node) error) (err error) { + index := self.proximityBin(node.Addr()) + record := self.db.findOrCreate(index, node.Addr(), node.Url()) + // callback on add node + // setting the node on the record, set it checked (for connectivity) + record.node = node + + glog.V(logger.Info).Infof("[KΛÐ]: add node record %v with node %v", record, node) + if cb != nil { + err = cb(record, node) + glog.V(logger.Info).Infof("[KΛÐ]: cb(%v, %v) ->%v", record, node, err) + if err != nil { + return fmt.Errorf("node %v not added: %v", node.Addr(), err) + } + } + record.connected = true + + defer self.lock.Unlock() + self.lock.Lock() + + // insert in kademlia table of active nodes + bucket := self.buckets[index] + // if bucket is full insertion replaces the worst node + // TODO: give priority to peers with active traffic + if worst, pos := bucket.insert(node); worst != nil { + glog.V(logger.Info).Infof("[KΛÐ]: replace node %v (%d) with node %v", worst, pos, node) + // no prox adjustment needed + // do not change count + } else { + glog.V(logger.Info).Infof("[KΛÐ]: add node %v to table", node) + self.count++ + self.adjustProxMore(index) + } + + return + +} + +// is the entrypoint called when a node is taken offline +func (self *Kademlia) Off(node Node, cb func(*NodeRecord, Node)) (err error) { + self.lock.Lock() + defer self.lock.Unlock() + + var found bool + index := self.proximityBin(node.Addr()) + bucket := self.buckets[index] + for i := 0; i < len(bucket.nodes); i++ { + if node.Addr() == bucket.nodes[i].Addr() { + found = true + bucket.nodes = append(bucket.nodes[:i], bucket.nodes[(i+1):]...) + } + } + + if !found { + return + } + glog.V(logger.Info).Infof("[KΛÐ]: remove node %v from table", node) + + self.count-- + if len(bucket.nodes) < bucket.size { + err = fmt.Errorf("insufficient nodes (%v) in bucket %v", len(bucket.nodes), index) + } + self.adjustProxLess(index) + + r := self.db.index[node.Addr()] + // callback on remove + if cb != nil { + cb(r, r.node) + } + r.node = nil + r.connected = false + + return +} + +// proxLimit is dynamically adjusted so that 1) there is no +// empty buckets in bin < proxLimit and 2) the sum of all items sare the maximum +// possible but lower than ProxBinSize +// adjust Prox (proxLimit and proxSize after an insertion of add nodes into bucket r) +func (self *Kademlia) adjustProxMore(r int) { + if r >= self.proxLimit { + exLimit := self.proxLimit + exSize := self.proxSize + self.proxSize++ + + var i int + for i = self.proxLimit; i < self.MaxProx && len(self.buckets[i].nodes) > 0 && self.proxSize-len(self.buckets[i].nodes) > self.ProxBinSize; i++ { + self.proxSize -= len(self.buckets[i].nodes) + } + self.proxLimit = i + + glog.V(logger.Detail).Infof("[KΛÐ]: Max Prox Bin: Lower Limit: %v (was %v): Bin Size: %v (was %v)", self.proxLimit, exLimit, self.proxSize, exSize) + } +} + +func (self *Kademlia) adjustProxLess(r int) { + exLimit := self.proxLimit + exSize := self.proxSize + if r >= self.proxLimit { + self.proxSize-- + } + + if r < self.proxLimit && len(self.buckets[r].nodes) == 0 { + for i := self.proxLimit - 1; i > r; i-- { + self.proxSize += len(self.buckets[i].nodes) + } + self.proxLimit = r + } else if self.proxLimit > 0 && r >= self.proxLimit-1 { + var i int + for i = self.proxLimit - 1; i > 0 && len(self.buckets[i].nodes)+self.proxSize <= self.ProxBinSize; i-- { + self.proxSize += len(self.buckets[i].nodes) + } + self.proxLimit = i + } + + if exLimit != self.proxLimit || exSize != self.proxSize { + glog.V(logger.Detail).Infof("[KΛÐ]: Max Prox Bin: Lower Limit: %v (was %v): Bin Size: %v (was %v)", self.proxLimit, exLimit, self.proxSize, exSize) + } +} + +/* +returns the list of nodes belonging to the same proximity bin +as the target. The most proximate bin will be the union of the bins between +proxLimit and MaxProx. +*/ +func (self *Kademlia) FindClosest(target Address, max int) []Node { + defer self.lock.RUnlock() + self.lock.RLock() + r := nodesByDistance{ + target: target, + } + index := self.proximityBin(target) + + start := index + var down bool + if index >= self.proxLimit { + index = self.proxLimit + start = self.MaxProx + down = true + } + var n int + limit := max + if max == 0 { + limit = 1000 + } + for { + + bucket := self.buckets[start].nodes + for i := 0; i < len(bucket); i++ { + r.push(bucket[i], limit) + n++ + } + if max == 0 && start <= index && (n > 0 || start == 0) || + max > 0 && down && start <= index && (n >= limit || n == self.count || start == 0) { + break + } + if down { + start-- + } else { + if start == self.MaxProx { + if index == 0 { + break + } + start = index - 1 + down = true + } else { + start++ + } + } + } + glog.V(logger.Detail).Infof("[KΛÐ]: serve %d (=<%d) nodes for target lookup %v (PO%d)", n, self.MaxProx, target, index) + return r.nodes +} + +func (self *Kademlia) binsize(p int) int { + b := self.buckets[p] + defer b.lock.RUnlock() + b.lock.RLock() + return len(b.nodes) +} + +func (self *Kademlia) FindBest() (node *NodeRecord, proxLimit int) { + return self.db.findBest(self.BucketSize, self.binsize) +} + +// adds node records to kaddb (persisted node record db) +func (self *Kademlia) Add(nrs []*NodeRecord) { + self.db.add(nrs, self.proximityBin) +} + +// in situ mutable bucket +type bucket struct { + size int + nodes []Node + lock sync.RWMutex +} + +// nodesByDistance is a list of nodes, ordered by distance to target. +type nodesByDistance struct { + nodes []Node + target Address +} + +func sortedByDistanceTo(target Address, slice []Node) bool { + var last Address + for i, node := range slice { + if i > 0 { + if target.ProxCmp(node.Addr(), last) < 0 { + return false + } + } + last = node.Addr() + } + return true +} + +// push(node, max) adds the given node to the list, keeping the total size +// below max elements. +func (h *nodesByDistance) push(node Node, max int) { + // returns the firt index ix such that func(i) returns true + ix := sort.Search(len(h.nodes), func(i int) bool { + return h.target.ProxCmp(h.nodes[i].Addr(), node.Addr()) >= 0 + }) + + if len(h.nodes) < max { + h.nodes = append(h.nodes, node) + } + if ix < len(h.nodes) { + copy(h.nodes[ix+1:], h.nodes[ix:]) + h.nodes[ix] = node + } +} + +// insert adds a peer to a bucket either by appending to existing items if +// bucket length does not exceed bucketSize, or by replacing the worst +// Node in the bucket +func (self *bucket) insert(node Node) (dropped Node, pos int) { + self.lock.Lock() + defer self.lock.Unlock() + if len(self.nodes) >= self.size { // >= allows us to add peers beyond the bucketsize limitation + dropped, pos = self.worstNode() + if dropped != nil { + self.nodes[pos] = node + glog.V(logger.Info).Infof("[KΛÐ] dropping node %v (%d)", dropped, pos) + dropped.Drop() + return + } + } + self.nodes = append(self.nodes, node) + return +} + +func (self *bucket) length(node Node) int { + self.lock.Lock() + defer self.lock.Unlock() + return len(self.nodes) +} + +// worst expunges the single worst node in a row, where worst entry is the node +// that has been inactive for the longests time +func (self *bucket) worstNode() (node Node, pos int) { + var oldest time.Time + for p, n := range self.nodes { + if (oldest == time.Time{}) || !oldest.Before(n.LastActive()) { + oldest = n.LastActive() + node = n + pos = p + } + } + return +} + +/* +Taking the proximity order relative to a fix point x classifies the points in +the space (n byte long byte sequences) into bins. Items in each are at +most half as distant from x as items in the previous bin. Given a sample of +uniformly distributed items (a hash function over arbitrary sequence) the +proximity scale maps onto series of subsets with cardinalities on a negative +exponential scale. + +It also has the property that any two item belonging to the same bin are at +most half as distant from each other as they are from x. + +If we think of random sample of items in the bins as connections in a network of interconnected nodes than relative proximity can serve as the basis for local +decisions for graph traversal where the task is to find a route between two +points. Since in every hop, the finite distance halves, there is +a guaranteed constant maximum limit on the number of hops needed to reach one +node from the other. +*/ + +func (self *Kademlia) proximityBin(other Address) (ret int) { + ret = proximity(self.addr, other) + if ret > self.MaxProx { + ret = self.MaxProx + } + return +} + +// provides keyrange for chunk db iteration +func (self *Kademlia) KeyRange(other Address) (start, stop Address) { + defer self.lock.RUnlock() + self.lock.RLock() + return KeyRange(self.addr, other, self.proxLimit) +} + +// save persists kaddb on disk (written to file on path in json format. +func (self *Kademlia) Save(path string, cb func(*NodeRecord, Node)) error { + return self.db.save(path, cb) +} + +// Load(path) loads the node record database (kaddb) from file on path. +func (self *Kademlia) Load(path string, cb func(*NodeRecord, Node) error) (err error) { + return self.db.load(path, cb) +} + +// kademlia table + kaddb table displayed with ascii +func (self *Kademlia) String() string { + + var rows []string + rows = append(rows, "=========================================================================") + rows = append(rows, fmt.Sprintf("%v : MaxProx: %d, ProxBinSize: %d, BucketSize: %d, proxLimit: %d, proxSize: %d", time.Now(), self.MaxProx, self.ProxBinSize, self.BucketSize, self.proxLimit, self.proxSize)) + + for i, b := range self.buckets { + + if i == self.proxLimit { + rows = append(rows, fmt.Sprintf("===================== PROX LIMIT: %d =================================", i)) + } + row := []string{fmt.Sprintf("%03d", i), fmt.Sprintf("%2d", len(b.nodes))} + var k int + c := self.db.cursors[i] + for ; k < len(b.nodes); k++ { + p := b.nodes[(c+k)%len(b.nodes)] + row = append(row, fmt.Sprintf("%s", p.Addr().String()[:8])) + if k == 3 { + break + } + } + for ; k < 3; k++ { + row = append(row, " ") + } + row = append(row, fmt.Sprintf("| %2d %2d", len(self.db.Nodes[i]), self.db.cursors[i])) + + for j, p := range self.db.Nodes[i] { + row = append(row, fmt.Sprintf("%08x", p.Addr[:4])) + if j == 2 { + break + } + } + rows = append(rows, strings.Join(row, " ")) + if i == self.MaxProx { + break + } + } + rows = append(rows, "=========================================================================") + return strings.Join(rows, "\n") +} diff --git a/common/kademlia/kademlia_test.go b/common/kademlia/kademlia_test.go new file mode 100644 index 0000000000..f36158c378 --- /dev/null +++ b/common/kademlia/kademlia_test.go @@ -0,0 +1,389 @@ +package kademlia + +import ( + "fmt" + "math/rand" + "reflect" + "testing" + "testing/quick" + "time" +) + +var ( + quickrand = rand.New(rand.NewSource(time.Now().Unix())) + quickcfgFindClosest = &quick.Config{MaxCount: 5000, Rand: quickrand} + quickcfgBootStrap = &quick.Config{MaxCount: 1000, Rand: quickrand} +) + +type testNode struct { + addr Address +} + +func (n *testNode) String() string { + return fmt.Sprintf("%x", n.addr[:]) +} + +func (n *testNode) Addr() Address { + return n.addr +} + +func (n *testNode) Drop() { +} + +func (n *testNode) Url() string { + return "" +} + +func (n *testNode) LastActive() time.Time { + return time.Now() +} + +func TestOn(t *testing.T) { + addr, ok := gen(Address{}, quickrand).(Address) + other, ok := gen(Address{}, quickrand).(Address) + if !ok { + t.Errorf("oops") + } + kad := New(addr, NewKadParams()) + err := kad.On(&testNode{addr: other}, nil) + _ = err +} + +func TestBootstrap(t *testing.T) { + + test := func(test *bootstrapTest) bool { + // for any node kad.le, Target and N + params := NewKadParams() + params.MaxProx = test.MaxProx + params.BucketSize = test.BucketSize + params.ProxBinSize = test.BucketSize + kad := New(test.Self, params) + var err error + + addr := RandomAddress() + prox := proximity(addr, test.Self) + + for p := 0; p <= prox; p++ { + var nrs []*NodeRecord + for i := 0; i < 3; i++ { + nrs = append(nrs, &NodeRecord{ + Addr: RandomAddressAt(test.Self, p), + }) + } + kad.Add(nrs) + } + + node := &testNode{addr} + + n := 0 + for n < 100 { + err = kad.On(node, nil) + if err != nil { + t.Errorf("backend not accepting node") + return false + } + var nrs []*NodeRecord + prox := proximity(test.Self, node.addr) + for i := 0; i < 13; i++ { + nrs = append(nrs, &NodeRecord{ + Addr: RandomAddressAt(test.Self, prox+1), + }) + } + kad.Add(nrs) + + record, _ := kad.FindBest() + if record == nil { + break + } + node = &testNode{record.Addr} + n++ + } + exp := test.BucketSize * (test.MaxProx + 1) + if kad.Count() != exp { + t.Errorf("incorrect number of peers, expected %d, got %d\n%v", exp, kad.Count(), kad) + return false + } + return true + } + if err := quick.Check(test, quickcfgBootStrap); err != nil { + t.Error(err) + } + +} + +func TestFindClosest(t *testing.T) { + + test := func(test *FindClosestTest) bool { + // for any node kad.le, Target and N + params := NewKadParams() + params.MaxProx = 10 + kad := New(test.Self, params) + var err error + // t.Logf("FindClosestTest %v: %v\n", len(test.All), test) + for _, node := range test.All { + err = kad.On(node, nil) + if err != nil { + t.Errorf("backend not accepting node") + return false + } + } + + if len(test.All) == 0 || test.N == 0 { + return true + } + nodes := kad.FindClosest(test.Target, test.N) + + // check that the number of results is min(N, kad.len) + wantN := test.N + if tlen := kad.Count(); tlen < test.N { + wantN = tlen + } + + if len(nodes) != wantN { + t.Errorf("wrong number of nodes: got %d, want %d", len(nodes), wantN) + return false + } + + if hasDuplicates(nodes) { + t.Errorf("result contains duplicates") + return false + } + + if !sortedByDistanceTo(test.Target, nodes) { + t.Errorf("result is not sorted by distance to target") + return false + } + + // check that the result nodes have minimum distance to target. + farthestResult := nodes[len(nodes)-1].Addr() + for i, b := range kad.buckets { + for j, n := range b.nodes { + if contains(nodes, n.Addr()) { + continue // don't run the check below for nodes in result + } + if test.Target.ProxCmp(n.Addr(), farthestResult) < 0 { + _ = i * j + t.Errorf("kad.le contains node that is closer to target but it's not in result") + // t.Logf("bucket %v, item %v\n", i, j) + // t.Logf(" Target: %x", test.Target) + // t.Logf(" Farthest Result: %x", farthestResult) + // t.Logf(" ID: %x (%d)", n.Addr(), kad.proximityBin(n.Addr())) + return false + } + } + } + return true + } + if err := quick.Check(test, quickcfgFindClosest); err != nil { + t.Error(err) + } +} + +type proxTest struct { + add bool + index int + addr Address +} + +var ( + addresses []Address +) + +func TestProxAdjust(t *testing.T) { + r := rand.New(rand.NewSource(time.Now().UnixNano())) + self := gen(Address{}, r).(Address) + params := NewKadParams() + params.MaxProx = 10 + kad := New(self, params) + + var err error + for i := 0; i < 100; i++ { + a := gen(Address{}, r).(Address) + addresses = append(addresses, a) + err = kad.On(&testNode{addr: a}, nil) + if err != nil { + t.Errorf("backend not accepting node") + return + } + if !kad.proxCheck(t) { + return + } + } + + test := func(test *proxTest) bool { + node := &testNode{test.addr} + if test.add { + kad.On(node, nil) + } else { + kad.Off(node, nil) + } + return kad.proxCheck(t) + } + if err := quick.Check(test, quickcfgFindClosest); err != nil { + t.Error(err) + } +} + +func TestSaveLoad(t *testing.T) { + r := rand.New(rand.NewSource(time.Now().UnixNano())) + addresses := gen([]Address{}, r).([]Address) + self := RandomAddress() + params := NewKadParams() + params.MaxProx = 10 + kad := New(self, params) + + var err error + + for _, a := range addresses { + err = kad.On(&testNode{addr: a}, nil) + if err != nil { + t.Errorf("backend not accepting node") + return + } + } + nodes := kad.FindClosest(self, 100) + path := "/tmp/bzz.peers" + err = kad.Save(path, nil) + if err != nil { + t.Fatalf("unepected error saving kaddb: %v", err) + } + kad = New(self, params) + err = kad.Load(path, nil) + if err != nil { + t.Fatalf("unepected error loading kaddb: %v", err) + } + for _, b := range kad.db.Nodes { + for _, node := range b { + err = kad.On(&testNode{node.Addr}, nil) + if err != nil { + t.Errorf("backend not accepting node") + return + } + } + } + loadednodes := kad.FindClosest(self, 100) + for i, node := range loadednodes { + if nodes[i].Addr() != node.Addr() { + t.Errorf("node mismatch at %d/%d: %v != %v", i, len(nodes), nodes[i].Addr(), node.Addr()) + } + } +} + +func (self *Kademlia) proxCheck(t *testing.T) bool { + var sum, i int + var b *bucket + for i, b = range self.buckets { + l := len(b.nodes) + // if we are in the high prox multibucket + if i >= self.proxLimit { + sum += l + } else if l == 0 { + t.Errorf("bucket %d empty, yet proxLimit is %d\n%v", len(b.nodes), self.proxLimit, self) + return false + } + } + // check if merged high prox bucket does not exceed size + if sum > 0 { + // if sum > self.ProxBinSize { + // t.Errorf("bucket %d is empty, yet proxSize is %d\n%v", i, self.proxSize, self) + // return false + // } + if sum != self.proxSize { + t.Errorf("proxSize incorrect, expected %v, got %v", sum, self.proxSize) + return false + } + if self.proxLimit > 0 && sum+len(self.buckets[self.proxLimit-1].nodes) < self.ProxBinSize { + t.Errorf("proxBinSize incorrect, expected %v got %v", sum, self.proxSize) + return false + } + } + return true +} + +type bootstrapTest struct { + MaxProx int + BucketSize int + Self Address +} + +func (*bootstrapTest) Generate(rand *rand.Rand, size int) reflect.Value { + t := &bootstrapTest{ + Self: gen(Address{}, rand).(Address), + MaxProx: 10 + rand.Intn(3), + BucketSize: rand.Intn(3) + 1, + } + return reflect.ValueOf(t) +} + +type FindClosestTest struct { + Self Address + Target Address + All []Node + N int +} + +func (c FindClosestTest) String() string { + return fmt.Sprintf("A: %064x\nT: %064x\n(%d)\n", c.Self[:], c.Target[:], c.N) +} + +func (*FindClosestTest) Generate(rand *rand.Rand, size int) reflect.Value { + t := &FindClosestTest{ + Self: gen(Address{}, rand).(Address), + Target: gen(Address{}, rand).(Address), + N: rand.Intn(bucketSize), + } + for _, a := range gen([]Address{}, rand).([]Address) { + t.All = append(t.All, &testNode{addr: a}) + } + return reflect.ValueOf(t) +} + +func (*proxTest) Generate(rand *rand.Rand, size int) reflect.Value { + var add bool + if rand.Intn(1) == 0 { + add = true + } + var t *proxTest + if add { + t = &proxTest{ + addr: gen(Address{}, rand).(Address), + add: add, + } + } else { + t = &proxTest{ + index: rand.Intn(len(addresses)), + add: add, + } + } + return reflect.ValueOf(t) +} + +func hasDuplicates(slice []Node) bool { + seen := make(map[Address]bool) + for _, node := range slice { + if seen[node.Addr()] { + return true + } + seen[node.Addr()] = true + } + return false +} + +func contains(nodes []Node, addr Address) bool { + for _, n := range nodes { + if n.Addr() == addr { + return true + } + } + return false +} + +// gen wraps quick.Value so it's easier to use. +// it generates a random value of the given value's type. +func gen(typ interface{}, rand *rand.Rand) interface{} { + v, ok := quick.Value(reflect.TypeOf(typ), rand) + if !ok { + panic(fmt.Sprintf("couldn't generate random value of type %T", typ)) + } + return v.Interface() +} diff --git a/common/registrar/ethreg/ethreg.go b/common/registrar/ethreg/ethreg.go index 626ebe1d74..7b3b41769c 100644 --- a/common/registrar/ethreg/ethreg.go +++ b/common/registrar/ethreg/ethreg.go @@ -20,18 +20,22 @@ import ( "math/big" "github.com/ethereum/go-ethereum/common/registrar" - "github.com/ethereum/go-ethereum/xeth" ) +type Backend interface { + registrar.Backend + AtStateNum(int64) registrar.Backend +} + // implements a versioned Registrar on an archiving full node type EthReg struct { - backend *xeth.XEth + backend Backend registry *registrar.Registrar } -func New(xe *xeth.XEth) (self *EthReg) { - self = &EthReg{backend: xe} - self.registry = registrar.New(xe) +func New(backend Backend) (self *EthReg) { + self = &EthReg{backend: backend} + self.registry = registrar.New(backend) return } @@ -40,9 +44,11 @@ func (self *EthReg) Registry() *registrar.Registrar { } func (self *EthReg) Resolver(n *big.Int) *registrar.Registrar { - xe := self.backend + var s registrar.Backend if n != nil { - xe = self.backend.AtStateNum(n.Int64()) + s = self.backend.AtStateNum(n.Int64()) + } else { + s = registrar.Backend(self.backend) } - return registrar.New(xe) + return registrar.New(s) } diff --git a/common/swap/swap.go b/common/swap/swap.go new file mode 100644 index 0000000000..c8cf7a7770 --- /dev/null +++ b/common/swap/swap.go @@ -0,0 +1,238 @@ +package swap + +import ( + "fmt" + "math/big" + "sync" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/logger/glog" +) + +// SwAP Swarm Accounting Protocol with +// Swift Automatic Payments +// a peer to peer micropayment system + +// public swap profile +// public parameters for SWAP, serializable config struct passed in handshake +type Profile struct { + BuyAt *big.Int // accepted max price for chunk + SellAt *big.Int // offered sale price for chunk + PayAt uint // threshold that triggers payment request + DropAt uint // threshold that triggers disconnect +} + +// Strategy encapsulates parameters relating to +// automatic deposit and automatic cashing +type Strategy struct { + AutoCashInterval time.Duration // default interval for autocash + AutoCashThreshold *big.Int // threshold that triggers autocash (wei) + AutoDepositInterval time.Duration // default interval for autocash + AutoDepositThreshold *big.Int // threshold that triggers autodeposit (wei) + AutoDepositBuffer *big.Int // buffer that is surplus for fork protection etc (wei) +} + +// Params extends the public profile with private parameters relating to +// automatic deposit and automatic cashing +type Params struct { + *Profile + *Strategy +} + +// Promise +// 3rd party Provable Promise of Payment +// issued by outPayment +// serialisable to send with Protocol +type Promise interface{} + +// interface for the peer protocol for testing or external alternative payment +type Protocol interface { + Pay(int, Promise) // units, payment proof + Drop() + String() string +} + +// interface for the (delayed) ougoing payment system with autodeposit +type OutPayment interface { + Issue(amount *big.Int) (promise Promise, err error) + AutoDeposit(interval time.Duration, threshold, buffer *big.Int) + Stop() +} + +// interface for the (delayed) incoming payment system with autocash +type InPayment interface { + Receive(promise Promise) (*big.Int, error) + AutoCash(cashInterval time.Duration, maxUncashed *big.Int) + Stop() +} + +// swap is the swarm accounting protocol instance +// * pairwise accounting and payments +type Swap struct { + lock sync.Mutex // mutex for balance access + balance int // units of chunk/retrieval request + local *Params // local peer's swap parameters + remote *Profile // remote peer's swap profile + proto Protocol // peer communication protocol + Payment +} + +type Payment struct { + Out OutPayment // outgoing payment handler + In InPayment // incoming payment handler + Buys, Sells bool +} + +// swap constructor +func New(local *Params, pm Payment, proto Protocol) (self *Swap, err error) { + + self = &Swap{ + local: local, + Payment: pm, + proto: proto, + } + + self.SetParams(local) + + return +} + +// entry point for setting remote swap profile (e.g from handshake or other message) +func (self *Swap) SetRemote(remote *Profile) { + defer self.lock.Unlock() + self.lock.Lock() + + self.remote = remote + if self.Sells && (remote.BuyAt.Cmp(common.Big0) <= 0 || self.local.SellAt.Cmp(common.Big0) <= 0 || remote.BuyAt.Cmp(self.local.SellAt) < 0) { + self.Out.Stop() + self.Sells = false + } + if self.Buys && (remote.SellAt.Cmp(common.Big0) <= 0 || self.local.BuyAt.Cmp(common.Big0) <= 0 || self.local.BuyAt.Cmp(self.remote.SellAt) < 0) { + self.In.Stop() + self.Buys = false + } + + glog.V(logger.Debug).Infof("[SWAP] <%v> remote profile set: pay at: %v, drop at: %v, buy at: %v, sell at: %v", self.proto, remote.PayAt, remote.DropAt, remote.BuyAt, remote.SellAt) + +} + +// to set strategy dynamically +func (self *Swap) SetParams(local *Params) { + defer self.lock.Unlock() + self.lock.Lock() + self.local = local + self.setParams(local) +} + +// caller holds the lock + +func (self *Swap) setParams(local *Params) { + + if self.Sells { + self.In.AutoCash(local.AutoCashInterval, local.AutoCashThreshold) + glog.V(logger.Info).Infof("[SWAP] <%v> set autocash to every %v, max uncashed limit: %v", self.proto, local.AutoCashInterval, local.AutoCashThreshold) + } else { + glog.V(logger.Info).Infof("[SWAP] <%v> autocash off (not selling)", self.proto) + } + if self.Buys { + self.Out.AutoDeposit(local.AutoDepositInterval, local.AutoDepositThreshold, local.AutoDepositBuffer) + glog.V(logger.Info).Infof("[SWAP] <%v> set autodeposit to every %v, pay at: %v, buffer: %v", self.proto, local.AutoDepositInterval, local.AutoDepositThreshold, local.AutoDepositBuffer) + } else { + glog.V(logger.Info).Infof("[SWAP] <%v> autodeposit off (not buying)", self.proto) + } +} + +// Add(n) +// n > 0 called when promised/provided n units of service +// n < 0 called when used/requested n units of service +func (self *Swap) Add(n int) error { + defer self.lock.Unlock() + self.lock.Lock() + self.balance += n + if !self.Sells && self.balance > 0 { + glog.V(logger.Detail).Infof("[SWAP] <%v> remote peer cannot have debt (unable to buy)", self.proto, self.balance) + self.proto.Drop() + return fmt.Errorf("[SWAP] <%v> remote peer cannot have debt (unable to buy)", self.proto, self.balance) + } + if !self.Buys && self.balance < 0 { + glog.V(logger.Detail).Infof("[SWAP] <%v> we cannot have debt (unable to buy)", self.proto, self.balance) + return fmt.Errorf("[SWAP] <%v> we cannot have debt (unable to buy)", self.proto, self.balance) + } + if self.balance >= int(self.local.DropAt) { + glog.V(logger.Detail).Infof("[SWAP] <%v> remote peer has too much debt (balance: %v, disconnect threshold: %v)", self.proto, self.balance, self.local.DropAt) + self.proto.Drop() + return fmt.Errorf("[SWAP] <%v> remote peer has too much debt (balance: %v, disconnect threshold: %v)", self.proto, self.balance, self.local.DropAt) + } else if self.balance <= -int(self.remote.PayAt) { + self.send() + } + return nil +} + +func (self *Swap) Balance() int { + defer self.lock.Unlock() + self.lock.Lock() + return self.balance +} + +// send(units) is called when payment is due +// In case of insolvency no promise is issued and sent, safe against fraud +// No return value: no error = payment is opportunistic = hang in till dropped +func (self *Swap) send() { + if self.local.BuyAt != nil && self.balance < 0 { + amount := big.NewInt(int64(-self.balance)) + amount.Mul(amount, self.remote.SellAt) + promise, err := self.Out.Issue(amount) + if err != nil { + glog.V(logger.Warn).Infof("[SWAP] <%v> cannot issue cheque (amount: %v, channel: %v): %v", self.proto, amount, self.Out, err) + } else { + glog.V(logger.Warn).Infof("[SWAP] <%v> cheque issued (amount: %v, channel: %v)", self.proto, amount, self.Out) + self.proto.Pay(-self.balance, promise) + self.balance = 0 + } + } +} + +// receive(units, promise) is called by the protocol when a payment msg is received +// returns error if promise is invalid. +func (self *Swap) Receive(units int, promise Promise) error { + if units <= 0 { + return fmt.Errorf("invalid units: %v <= 0", units) + } + + price := new(big.Int).SetInt64(int64(units)) + price.Mul(price, self.local.SellAt) + + amount, err := self.In.Receive(promise) + + if err != nil { + err = fmt.Errorf("invalid promise: %v", err) + } else if price.Cmp(amount) != 0 { + // verify amount = units * unit sale price + return fmt.Errorf("invalid amount: %v = %v * %v (units sent in msg * agreed sale unit price) != %v (signed in cheque)", price, units, self.local.SellAt, amount) + } + if err != nil { + glog.V(logger.Detail).Infof("[SWAP] <%v> invalid promise (amount: %v, channel: %v): %v", self.proto, amount, self.In, err) + return err + } + + // credit remote peer with units + self.Add(-units) + glog.V(logger.Detail).Infof("[SWAP] <%v> received promise (amount: %v, channel: %v): %v", self.proto, amount, self.In, promise) + + return nil +} + +// stop() causes autocash loop to terminate. +// Called after protocol handle loop terminates. +func (self *Swap) Stop() { + defer self.lock.Unlock() + self.lock.Lock() + if self.Buys { + self.Out.Stop() + } + if self.Sells { + self.In.Stop() + } +} diff --git a/common/swap/swap_test.go b/common/swap/swap_test.go new file mode 100644 index 0000000000..664cd81d20 --- /dev/null +++ b/common/swap/swap_test.go @@ -0,0 +1,178 @@ +package swap + +import ( + "math/big" + "testing" + "time" + + "github.com/ethereum/go-ethereum/common" +) + +type testInPayment struct { + received []*testPromise + autocashInterval time.Duration + autocashLimit *big.Int +} + +type testPromise struct { + amount *big.Int +} + +func (self *testInPayment) Receive(promise Promise) (*big.Int, error) { + p := promise.(*testPromise) + self.received = append(self.received, p) + return p.amount, nil +} + +func (self *testInPayment) AutoCash(interval time.Duration, limit *big.Int) { + self.autocashInterval = interval + self.autocashLimit = limit +} + +func (self *testInPayment) Cash() (string, error) { return "", nil } + +func (self *testInPayment) Stop() {} + +type testOutPayment struct { + deposits []*big.Int + autodepositInterval time.Duration + autodepositThreshold *big.Int + autodepositBuffer *big.Int +} + +func (self *testOutPayment) Issue(amount *big.Int) (promise Promise, err error) { + return &testPromise{amount}, nil +} + +func (self *testOutPayment) Deposit(amount *big.Int) (string, error) { + self.deposits = append(self.deposits, amount) + return "", nil +} + +func (self *testOutPayment) AutoDeposit(interval time.Duration, threshold, buffer *big.Int) { + self.autodepositInterval = interval + self.autodepositThreshold = threshold + self.autodepositBuffer = buffer +} + +func (self *testOutPayment) Stop() {} + +type testProtocol struct { + drop bool + amounts []int + promises []*testPromise +} + +func (self *testProtocol) Drop() { + self.drop = true +} + +func (self *testProtocol) String() string { + return "" +} + +func (self *testProtocol) Pay(amount int, promise Promise) { + p := promise.(*testPromise) + self.promises = append(self.promises, p) + self.amounts = append(self.amounts, amount) +} + +func TestSwap(t *testing.T) { + + strategy := &Strategy{ + AutoCashInterval: 1 * time.Second, + AutoCashThreshold: big.NewInt(20), + AutoDepositInterval: 1 * time.Second, + AutoDepositThreshold: big.NewInt(20), + AutoDepositBuffer: big.NewInt(40), + } + + local := &Params{ + Profile: &Profile{ + PayAt: 5, + DropAt: 10, + BuyAt: common.Big3, + SellAt: common.Big2, + }, + Strategy: strategy, + } + + in := &testInPayment{} + out := &testOutPayment{} + proto := &testProtocol{} + + swap, _ := New(local, Payment{In: in, Out: out, Buys: true, Sells: true}, proto) + + if in.autocashInterval != strategy.AutoCashInterval { + t.Fatalf("autocash interval not properly set, expect %v, got ", strategy.AutoCashInterval, in.autocashInterval) + } + if out.autodepositInterval != strategy.AutoDepositInterval { + t.Fatalf("autodeposit interval not properly set, expect %v, got ", strategy.AutoDepositInterval, out.autodepositInterval) + } + + remote := &Profile{ + PayAt: 3, + DropAt: 10, + BuyAt: common.Big2, + SellAt: common.Big3, + } + swap.SetRemote(remote) + + swap.Add(9) + if proto.drop { + t.Fatalf("not expected peer to be dropped") + } + swap.Add(1) + if !proto.drop { + t.Fatalf("expected peer to be dropped") + } + if !proto.drop { + t.Fatalf("expected peer to be dropped") + } + proto.drop = false + + swap.Receive(10, &testPromise{big.NewInt(20)}) + if swap.balance != 0 { + t.Fatalf("expected zero balance, got %v", swap.balance) + } + + if len(proto.amounts) != 0 { + t.Fatalf("expected zero balance, got %v", swap.balance) + } + + swap.Add(-2) + if len(proto.amounts) > 0 { + t.Fatalf("expected no payments yet, got %v", proto.amounts) + } + + swap.Add(-1) + if len(proto.amounts) != 1 { + t.Fatalf("expected one payment, got %v", len(proto.amounts)) + } + + if proto.amounts[0] != 3 { + t.Fatalf("expected payment for %v units, got %v", proto.amounts[0]) + } + + exp := new(big.Int).Mul(big.NewInt(int64(proto.amounts[0])), remote.SellAt) + if proto.promises[0].amount.Cmp(exp) != 0 { + t.Fatalf("expected payment amount %v, got %v", exp, proto.promises[0].amount) + } + + swap.SetParams(&Params{ + Profile: &Profile{ + PayAt: 5, + DropAt: 10, + BuyAt: common.Big3, + SellAt: common.Big2, + }, + Strategy: &Strategy{ + AutoCashInterval: 2 * time.Second, + AutoCashThreshold: big.NewInt(40), + AutoDepositInterval: 2 * time.Second, + AutoDepositThreshold: big.NewInt(40), + AutoDepositBuffer: big.NewInt(60), + }, + }) + +} diff --git a/common/types.go b/common/types.go index b1666d7338..4e5500c06c 100644 --- a/common/types.go +++ b/common/types.go @@ -187,3 +187,16 @@ func PP(value []byte) string { return fmt.Sprintf("%x...%x", value[:4], value[len(value)-4]) } + +func (a *Address) MarshalJSON() (out []byte, err error) { + return []byte(quote(a.Hex())), nil +} + +func (m *Address) UnmarshalJSON(value []byte) error { + m.Set(HexToAddress(string(value[1 : len(value)-1]))) + return nil +} + +func quote(s string) string { + return `"` + s + `"` +} diff --git a/core/genesis.go b/core/genesis.go index d8c6e9cea3..6e54f50495 100644 --- a/core/genesis.go +++ b/core/genesis.go @@ -35,6 +35,11 @@ import ( "github.com/ethereum/go-ethereum/params" ) +const ( + TestAccount = "e273f01c99144c438695e10f24926dc1f9fbf62d" + TestBalance = "1000000000000" +) + // WriteGenesisBlock writes the genesis block to the database as block number 0 func WriteGenesisBlock(chainDb ethdb.Database, reader io.Reader) (*types.Block, error) { contents, err := ioutil.ReadAll(reader) diff --git a/rpc/api/bzz.go b/rpc/api/bzz.go new file mode 100644 index 0000000000..c258879857 --- /dev/null +++ b/rpc/api/bzz.go @@ -0,0 +1,278 @@ +// Copyright 2015 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with go-ethereum. If not, see . + +package api + +import ( + "encoding/json" + "fmt" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/node" + "github.com/ethereum/go-ethereum/rpc/codec" + "github.com/ethereum/go-ethereum/rpc/shared" + "github.com/ethereum/go-ethereum/swarm" +) + +const ( + BzzApiVersion = "1.0" +) + +// eth api provider +// See https://github.com/ethereum/wiki/wiki/JSON-RPC +type bzzApi struct { + swarm *swarm.Swarm + methods map[string]bzzhandler + codec codec.ApiCoder +} + +// eth callback handler +type bzzhandler func(*bzzApi, *shared.Request) (interface{}, error) + +var ( + bzzMapping = map[string]bzzhandler{ + "bzz_info": (*bzzApi).Info, + "bzz_issue": (*bzzApi).Issue, + "bzz_cash": (*bzzApi).Cash, + "bzz_deposit": (*bzzApi).Deposit, + "bzz_register": (*bzzApi).Register, + "bzz_resolve": (*bzzApi).Resolve, + "bzz_download": (*bzzApi).Download, + "bzz_upload": (*bzzApi).Upload, + "bzz_get": (*bzzApi).Get, + "bzz_put": (*bzzApi).Put, + "bzz_modify": (*bzzApi).Modify, + } +) + +func newSwarmOfflineError(method string) error { + return shared.NewNotAvailableError(method, "swarm offline") +} + +// create new bzzApi instance +func NewBzzApi(stack *node.Node, codec codec.Codec) *bzzApi { + var swarm *swarm.Swarm + stack.Service(&swarm) + return &bzzApi{swarm, bzzMapping, codec.New(nil)} +} + +// collection with supported methods +func (self *bzzApi) Methods() []string { + methods := make([]string, len(self.methods)) + i := 0 + for k := range self.methods { + methods[i] = k + i++ + } + return methods +} + +// Execute given request +func (self *bzzApi) Execute(req *shared.Request) (interface{}, error) { + if callback, ok := self.methods[req.Method]; ok { + return callback(self, req) + } + + return nil, shared.NewNotImplementedError(req.Method) +} + +func (self *bzzApi) Name() string { + return shared.BzzApiName +} + +func (self *bzzApi) ApiVersion() string { + return BzzApiVersion +} + +func (self *bzzApi) Info(req *shared.Request) (interface{}, error) { + s := self.swarm + if s == nil { + return nil, newSwarmOfflineError(req.Method) + } + return s.Api().Info(), nil +} + +func (self *bzzApi) Issue(req *shared.Request) (interface{}, error) { + s := self.swarm + if s == nil { + return nil, newSwarmOfflineError(req.Method) + } + + args := new(BzzIssueArgs) + if err := self.codec.Decode(req.Params, &args); err != nil { + return nil, shared.NewDecodeParamError(err.Error()) + } + + cheque, err := s.Api().Issue(common.HexToAddress(args.Beneficiary), args.Amount) + if err != nil { + return nil, shared.NewDecodeParamError(err.Error()) + } + + out, err := json.MarshalIndent(cheque, " ", "") + if err != nil { + return nil, shared.NewDecodeParamError(err.Error()) + } + + return string(out), nil +} + +func (self *bzzApi) Cash(req *shared.Request) (interface{}, error) { + s := self.swarm + if s == nil { + return nil, newSwarmOfflineError(req.Method) + } + + args := new(BzzCashArgs) + if err := self.codec.Decode(req.Params, &args); err != nil { + return nil, shared.NewDecodeParamError(err.Error()) + } + + return s.Api().Cash(args.Cheque) + +} + +func (self *bzzApi) Deposit(req *shared.Request) (interface{}, error) { + s := self.swarm + if s == nil { + return nil, newSwarmOfflineError(req.Method) + } + + args := new(BzzDepositArgs) + if err := self.codec.Decode(req.Params, &args); err != nil { + return nil, shared.NewDecodeParamError(err.Error()) + } + + return s.Api().Deposit(args.Amount) +} + +func (self *bzzApi) Register(req *shared.Request) (interface{}, error) { + s := self.swarm + if s == nil { + return nil, newSwarmOfflineError(req.Method) + } + + args := new(BzzRegisterArgs) + if err := self.codec.Decode(req.Params, &args); err != nil { + return nil, shared.NewDecodeParamError(err.Error()) + } + + err := s.Api().Register(common.HexToAddress(args.Address), args.Domain, common.HexToHash(args.ContentHash)) + return err == nil, err +} + +func (self *bzzApi) Resolve(req *shared.Request) (interface{}, error) { + s := self.swarm + if s == nil { + return nil, newSwarmOfflineError(req.Method) + } + + args := new(BzzResolveArgs) + if err := self.codec.Decode(req.Params, &args); err != nil { + return nil, shared.NewDecodeParamError(err.Error()) + } + + key, err := s.Api().Resolve(args.Domain) + return key.Hex(), err +} + +func (self *bzzApi) Download(req *shared.Request) (interface{}, error) { + + s := self.swarm + if s == nil { + return nil, newSwarmOfflineError(req.Method) + } + + args := new(BzzDownloadArgs) + if err := self.codec.Decode(req.Params, &args); err != nil { + return nil, shared.NewDecodeParamError(err.Error()) + } + + err := s.Api().Download(args.BzzPath, args.LocalPath) + return err == nil, err +} + +func (self *bzzApi) Upload(req *shared.Request) (interface{}, error) { + + s := self.swarm + if s == nil { + return nil, newSwarmOfflineError(req.Method) + } + + args := new(BzzUploadArgs) + if err := self.codec.Decode(req.Params, &args); err != nil { + return nil, shared.NewDecodeParamError(err.Error()) + } + + return s.Api().Upload(args.LocalPath, args.Index) +} + +func (self *bzzApi) Get(req *shared.Request) (interface{}, error) { + + s := self.swarm + if s == nil { + return nil, newSwarmOfflineError(req.Method) + } + + args := new(BzzGetArgs) + if err := self.codec.Decode(req.Params, &args); err != nil { + return nil, shared.NewDecodeParamError(err.Error()) + } + + var content []byte + var mimeType string + var status, size int + var err error + content, mimeType, status, size, err = s.Api().Get(args.Path) + + obj := map[string]string{ + "content": string(content), + "contentType": mimeType, + "status": fmt.Sprintf("%v", status), + "size": fmt.Sprintf("%v", size), + } + + return obj, err +} + +func (self *bzzApi) Put(req *shared.Request) (interface{}, error) { + + s := self.swarm + if s == nil { + return nil, newSwarmOfflineError(req.Method) + } + + args := new(BzzPutArgs) + if err := self.codec.Decode(req.Params, &args); err != nil { + return nil, shared.NewDecodeParamError(err.Error()) + } + + return s.Api().Put(args.Content, args.ContenType) +} + +func (self *bzzApi) Modify(req *shared.Request) (interface{}, error) { + + s := self.swarm + if s == nil { + return nil, newSwarmOfflineError(req.Method) + } + + args := new(BzzModifyArgs) + if err := self.codec.Decode(req.Params, &args); err != nil { + return nil, shared.NewDecodeParamError(err.Error()) + } + + return s.Api().Modify(args.RootHash, args.Path, args.ContentHash, args.ContentType) +} diff --git a/rpc/api/bzz_args.go b/rpc/api/bzz_args.go new file mode 100644 index 0000000000..2aee255e15 --- /dev/null +++ b/rpc/api/bzz_args.go @@ -0,0 +1,322 @@ +// Copyright 2015 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with go-ethereum. If not, see . + +package api + +import ( + "encoding/json" + "math/big" + + "github.com/ethereum/go-ethereum/common/chequebook" + "github.com/ethereum/go-ethereum/rpc/shared" +) + +type BzzDepositArgs struct { + Amount *big.Int +} + +func (args *BzzDepositArgs) UnmarshalJSON(b []byte) (err error) { + var obj []interface{} + if err := json.Unmarshal(b, &obj); err != nil { + return shared.NewDecodeParamError(err.Error()) + } + + if len(obj) < 1 { + return shared.NewInsufficientParamsError(len(obj), 1) + } + + amount, ok := obj[0].(string) + if !ok { + return shared.NewInvalidTypeError("Amount", "not a string") + } + args.Amount, ok = new(big.Int).SetString(amount, 10) + if !ok { + return shared.NewInvalidTypeError("Amount", "not a number") + } + + return nil +} + +type BzzCashArgs struct { + Cheque *chequebook.Cheque +} + +func (args *BzzCashArgs) UnmarshalJSON(b []byte) (err error) { + var obj []interface{} + if err := json.Unmarshal(b, &obj); err != nil { + return shared.NewDecodeParamError(err.Error()) + } + + if len(obj) < 1 { + return shared.NewInsufficientParamsError(len(obj), 1) + } + + chequestr, ok := obj[0].(string) + if !ok { + return shared.NewInvalidTypeError("Cheque", "not a string") + } + var cheque chequebook.Cheque + err = json.Unmarshal([]byte(chequestr), &cheque) + if err != nil { + return shared.NewDecodeParamError(err.Error()) + } + args.Cheque = &cheque + + return nil +} + +type BzzIssueArgs struct { + Beneficiary string + Amount *big.Int +} + +func (args *BzzIssueArgs) UnmarshalJSON(b []byte) (err error) { + var obj []interface{} + if err := json.Unmarshal(b, &obj); err != nil { + return shared.NewDecodeParamError(err.Error()) + } + + if len(obj) < 2 { + return shared.NewInsufficientParamsError(len(obj), 2) + } + + beneficiary, ok := obj[0].(string) + if !ok { + return shared.NewInvalidTypeError("Amount", "not a string") + } + args.Beneficiary = beneficiary + + amount, ok := obj[1].(string) + if !ok { + return shared.NewInvalidTypeError("Amount", "not a string") + } + args.Amount, ok = new(big.Int).SetString(amount, 10) + if !ok { + return shared.NewInvalidTypeError("Amount", "not a number") + } + + return nil +} + +type BzzRegisterArgs struct { + Address, ContentHash, Domain string +} + +func (args *BzzRegisterArgs) UnmarshalJSON(b []byte) (err error) { + var obj []interface{} + if err := json.Unmarshal(b, &obj); err != nil { + return shared.NewDecodeParamError(err.Error()) + } + + if len(obj) < 3 { + return shared.NewInsufficientParamsError(len(obj), 1) + } + + addstr, ok := obj[0].(string) + if !ok { + return shared.NewInvalidTypeError("Address", "not a string") + } + args.Address = addstr + + addstr, ok = obj[1].(string) + if !ok { + return shared.NewInvalidTypeError("Domain", "not a string") + } + args.Domain = addstr + + addstr, ok = obj[2].(string) + if !ok { + return shared.NewInvalidTypeError("ContentHash", "not a string") + } + args.ContentHash = addstr + + return nil +} + +type BzzResolveArgs struct { + Domain string +} + +func (args *BzzResolveArgs) UnmarshalJSON(b []byte) (err error) { + var obj []interface{} + if err := json.Unmarshal(b, &obj); err != nil { + return shared.NewDecodeParamError(err.Error()) + } + + if len(obj) < 1 { + return shared.NewInsufficientParamsError(len(obj), 1) + } + + addstr, ok := obj[0].(string) + if !ok { + return shared.NewInvalidTypeError("Domain", "not a string") + } + args.Domain = addstr + + return nil +} + +type BzzDownloadArgs struct { + BzzPath, LocalPath string +} + +func (args *BzzDownloadArgs) UnmarshalJSON(b []byte) (err error) { + var obj []interface{} + if err := json.Unmarshal(b, &obj); err != nil { + return shared.NewDecodeParamError(err.Error()) + } + + if len(obj) < 2 { + return shared.NewInsufficientParamsError(len(obj), 1) + } + + addstr, ok := obj[0].(string) + if !ok { + return shared.NewInvalidTypeError("BzzPath", "not a string") + } + args.BzzPath = addstr + + addstr, ok = obj[1].(string) + if !ok { + return shared.NewInvalidTypeError("LocalPath", "not a string") + } + args.LocalPath = addstr + + return nil +} + +type BzzUploadArgs struct { + LocalPath, Index string +} + +func (args *BzzUploadArgs) UnmarshalJSON(b []byte) (err error) { + var obj []interface{} + if err := json.Unmarshal(b, &obj); err != nil { + return shared.NewDecodeParamError(err.Error()) + } + + if len(obj) < 1 { + return shared.NewInsufficientParamsError(len(obj), 1) + } + + addstr, ok := obj[0].(string) + if !ok { + return shared.NewInvalidTypeError("LocalPath", "not a string") + } + args.LocalPath = addstr + + if len(obj) > 1 { + addstr, ok := obj[1].(string) + if ok { + args.Index = addstr + } + } + + return nil +} + +type BzzGetArgs struct { + Path string +} + +func (args *BzzGetArgs) UnmarshalJSON(b []byte) (err error) { + var obj []interface{} + if err := json.Unmarshal(b, &obj); err != nil { + return shared.NewDecodeParamError(err.Error()) + } + + if len(obj) < 1 { + return shared.NewInsufficientParamsError(len(obj), 1) + } + + addstr, ok := obj[0].(string) + if !ok { + return shared.NewInvalidTypeError("Path", "not a string") + } + args.Path = addstr + + return nil +} + +type BzzPutArgs struct { + Content, ContenType string +} + +func (args *BzzPutArgs) UnmarshalJSON(b []byte) (err error) { + var obj []interface{} + if err := json.Unmarshal(b, &obj); err != nil { + return shared.NewDecodeParamError(err.Error()) + } + + if len(obj) < 1 { + return shared.NewInsufficientParamsError(len(obj), 1) + } + + addstr, ok := obj[0].(string) + if !ok { + return shared.NewInvalidTypeError("Content", "not a string") + } + args.Content = addstr + + addstr, ok = obj[1].(string) + if !ok { + return shared.NewInvalidTypeError("ContenType", "not a string") + } + args.ContenType = addstr + + return nil +} + +type BzzModifyArgs struct { + RootHash, Path, ContentHash, ContentType string +} + +func (args *BzzModifyArgs) UnmarshalJSON(b []byte) (err error) { + var obj []interface{} + if err := json.Unmarshal(b, &obj); err != nil { + return shared.NewDecodeParamError(err.Error()) + } + + if len(obj) < 2 { + return shared.NewInsufficientParamsError(len(obj), 1) + } + + addstr, ok := obj[0].(string) + if !ok { + return shared.NewInvalidTypeError("RootHash", "not a string") + } + args.RootHash = addstr + + addstr, ok = obj[1].(string) + if !ok { + return shared.NewInvalidTypeError("Path", "not a string") + } + args.Path = addstr + + if len(obj) >= 4 { + addstr, ok = obj[2].(string) + if ok { + args.ContentHash = addstr + } + + addstr, ok = obj[3].(string) + if ok { + args.ContentType = addstr + } + } + + return nil +} diff --git a/rpc/api/bzz_js.go b/rpc/api/bzz_js.go new file mode 100644 index 0000000000..50bbd43d07 --- /dev/null +++ b/rpc/api/bzz_js.go @@ -0,0 +1,95 @@ +// Copyright 2015 The go-ethereum Authors +// This file is part of go-ethereum. +// +// go-ethereum is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// go-ethereum is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with go-ethereum. If not, see . + +package api + +const Bzz_JS = ` +web3._extend({ + property: 'bzz', + methods: + [ + new web3._extend.Method({ + name: 'deposit', + call: 'bzz_deposit', + params: 1, + inputFormatter: [null] + }), + new web3._extend.Method({ + name: 'info', + call: 'bzz_info', + params: 1, + inputFormatter: [null] + }), + new web3._extend.Method({ + name: 'cash', + call: 'bzz_cash', + params: 1, + inputFormatter: [null] + }), + new web3._extend.Method({ + name: 'issue', + call: 'bzz_issue', + params: 2, + inputFormatter: [null, null] + }), + new web3._extend.Method({ + name: 'register', + call: 'bzz_register', + params: 3, + inputFormatter: [null, null, null] + }), + new web3._extend.Method({ + name: 'resolve', + call: 'bzz_resolve', + params: 1, + inputFormatter: [null] + }), + new web3._extend.Method({ + name: 'download', + call: 'bzz_download', + params: 2, + inputFormatter: [null, null] + }), + new web3._extend.Method({ + name: 'upload', + call: 'bzz_upload', + params: 2, + inputFormatter: [null, null] + }), + new web3._extend.Method({ + name: 'get', + call: 'bzz_get', + params: 1, + inputFormatter: [null] + }), + new web3._extend.Method({ + name: 'put', + call: 'bzz_put', + params: 2, + inputFormatter: [null, null] + }), + new web3._extend.Method({ + name: 'modify', + call: 'bzz_modify', + params: 4, + inputFormatter: [null, null, null, null] + }) + ], + properties: + [ + ] +}); +` diff --git a/rpc/api/utils.go b/rpc/api/utils.go index 794b6abeea..d52f6b3dc3 100644 --- a/rpc/api/utils.go +++ b/rpc/api/utils.go @@ -54,8 +54,28 @@ var ( "startRPC", "stopNatSpec", "stopRPC", + "setGlobalRegistrar", + "setHashReg", + "setUrlHint", + "saveInfo", + "getContractInfo", + "sleep", + "httpGet", "verbosity", }, + "bzz": []string{ + "info", + "issue", + "cash", + "deposit", + "register", + "resolve", + "download", + "upload", + "get", + "put", + "modify", + }, "db": []string{ "getString", "putString", @@ -102,7 +122,7 @@ var ( "hashrate", "mining", "namereg", - "pendingTransactions", + "getPendingTransactions", "resend", "sendRawTransaction", "sendTransaction", @@ -116,6 +136,7 @@ var ( "setExtra", "setGasPrice", "startAutoDAG", + "setEtherbase", "start", "stopAutoDAG", "stop", @@ -173,6 +194,8 @@ func ParseApiString(apistr string, codec codec.Codec, xeth *xeth.XEth, stack *no switch strings.ToLower(strings.TrimSpace(name)) { case shared.AdminApiName: apis[i] = NewAdminApi(xeth, stack, codec) + case shared.BzzApiName: + apis[i] = NewBzzApi(stack, codec) case shared.DebugApiName: apis[i] = NewDebugApi(xeth, eth, codec) case shared.DbApiName: @@ -204,6 +227,8 @@ func Javascript(name string) string { switch strings.ToLower(strings.TrimSpace(name)) { case shared.AdminApiName: return Admin_JS + case shared.BzzApiName: + return Bzz_JS case shared.DebugApiName: return Debug_JS case shared.DbApiName: diff --git a/rpc/shared/utils.go b/rpc/shared/utils.go index b13e9eb1b4..1590265a01 100644 --- a/rpc/shared/utils.go +++ b/rpc/shared/utils.go @@ -20,6 +20,7 @@ import "strings" const ( AdminApiName = "admin" + BzzApiName = "bzz" EthApiName = "eth" DbApiName = "db" DebugApiName = "debug" @@ -37,7 +38,7 @@ const ( var ( // All API's AllApis = strings.Join([]string{ - AdminApiName, DbApiName, EthApiName, DebugApiName, MinerApiName, NetApiName, + AdminApiName, BzzApiName, DbApiName, EthApiName, DebugApiName, MinerApiName, NetApiName, ShhApiName, TxPoolApiName, PersonalApiName, Web3ApiName, }, ",") ) diff --git a/swarm/api/api.go b/swarm/api/api.go new file mode 100644 index 0000000000..11bf4d81ec --- /dev/null +++ b/swarm/api/api.go @@ -0,0 +1,456 @@ +package api + +import ( + "bufio" + "fmt" + "io" + "math/big" + "net/http" + "os" + "path/filepath" + "regexp" + "strings" + "sync" + + "github.com/ethereum/go-ethereum/swarm/storage" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/chequebook" + "github.com/ethereum/go-ethereum/common/registrar" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/logger/glog" +) + +var ( + hashMatcher = regexp.MustCompile("^[0-9A-Fa-f]{64}") + slashes = regexp.MustCompile("/+") + domainAndVersion = regexp.MustCompile("[@:;,]+") +) + +/* +Api implements webserver/file system related content storage and retrieval +on top of the dpa +it is the public interface of the dpa which is included in the ethereum stack +*/ +type Api struct { + dpa *storage.DPA + registrar registrar.VersionedRegistrar + conf *Config +} + +//the api constructor initialises +func NewApi(dpa *storage.DPA, registrar registrar.VersionedRegistrar, conf *Config) (self *Api) { + return &Api{dpa, registrar, conf} +} + +// this should move over to chequebook ipc api +func (self *Api) Issue(beneficiary common.Address, amount *big.Int) (cheque *chequebook.Cheque, err error) { + return self.conf.Swap.Chequebook().Issue(beneficiary, amount) +} + +func (self *Api) Cash(cheque *chequebook.Cheque) (txhash string, err error) { + return self.conf.Swap.Chequebook().Cash(cheque) +} + +func (self *Api) Deposit(amount *big.Int) (txhash string, err error) { + return self.conf.Swap.Chequebook().Deposit(amount) +} + +// serialisable info about swarm +type Info struct { + *Config + *chequebook.Params +} + +func (self *Api) Info() *Info { + + return &Info{ + Config: self.conf, + Params: chequebook.ContractParams, + } + +} + +// Get uses iterative manifest retrieval and prefix matching +// to resolve path to content using dpa retrieve +func (self *Api) Get(bzzpath string) (content []byte, mimeType string, status int, size int, err error) { + var reader storage.SectionReader + reader, mimeType, status, err = self.getPath("/" + bzzpath) + if err != nil { + return + } + content = make([]byte, reader.Size()) + size, err = reader.Read(content) + if err == io.EOF { + err = nil + } + return +} + +// Put provides singleton manifest creation and optional name registration +// on top of dpa store +func (self *Api) Put(content, contentType string) (string, error) { + sr := io.NewSectionReader(strings.NewReader(content), 0, int64(len(content))) + wg := &sync.WaitGroup{} + key, err := self.dpa.Store(sr, wg) + if err != nil { + return "", err + } + manifest := fmt.Sprintf(`{"entries":[{"hash":"%v","contentType":"%s"}]}`, key, contentType) + sr = io.NewSectionReader(strings.NewReader(manifest), 0, int64(len(manifest))) + key, err = self.dpa.Store(sr, wg) + if err != nil { + return "", err + } + wg.Wait() + return key.String(), nil +} + +func (self *Api) Modify(rootHash, path, contentHash, contentType string) (newRootHash string, err error) { + root := common.Hex2Bytes(rootHash) + trie, err := loadManifest(self.dpa, root) + if err != nil { + return + } + + if contentHash != "" { + entry := &manifestTrieEntry{ + Path: path, + Hash: contentHash, + ContentType: contentType, + } + trie.addEntry(entry) + } else { + trie.deleteEntry(path) + } + + err = trie.recalcAndStore() + if err != nil { + return + } + return trie.hash.String(), nil +} + +const maxParallelFiles = 5 + +// Download replicates the manifest path structure on the local filesystem +// under localpath +func (self *Api) Download(bzzpath, localpath string) (err error) { + lpath, err := filepath.Abs(filepath.Clean(localpath)) + if err != nil { + return + } + err = os.MkdirAll(lpath, os.ModePerm) + if err != nil { + return + } + + parts := slashes.Split(bzzpath, 3) + if len(parts) < 2 { + return fmt.Errorf("Invalid bzz path") + } + hostPort := parts[1] + var path string + if len(parts) > 2 { + path = regularSlashes(parts[2]) + "/" + } + glog.V(logger.Debug).Infof("[BZZ] Swarm: host: '%s', path '%s' requested.", hostPort, path) + + //resolving host and port + var key storage.Key + key, err = self.Resolve(hostPort) + if err != nil { + err = errResolve(err) + glog.V(logger.Debug).Infof("[BZZ] Swarm: error : %v", err) + return + } + + trie, err := loadManifest(self.dpa, key) + if err != nil { + glog.V(logger.Debug).Infof("[BZZ] Swarm: loadManifestTrie error: %v", err) + return + } + + type downloadListEntry struct { + key storage.Key + path string + } + + var list []*downloadListEntry + var mde, mderr error + + prevPath := lpath + err = trie.listWithPrefix(path, func(entry *manifestTrieEntry, suffix string) { // TODO: paralellize + key := common.Hex2Bytes(entry.Hash) + path := lpath + "/" + suffix + dir := filepath.Dir(path) + if dir != prevPath { + mde = os.MkdirAll(dir, os.ModePerm) + if mde != nil { + mderr = mde + } + prevPath = dir + } + if (mde == nil) && (path != dir+"/") { + list = append(list, &downloadListEntry{key: key, path: path}) + } + }) + if err == nil { + err = mderr + } + + cnt := len(list) + errors := make([]error, cnt) + done := make(chan bool, maxParallelFiles) + dcnt := 0 + + for i, entry := range list { + if i >= dcnt+maxParallelFiles { + <-done + dcnt++ + } + go func(i int, entry *downloadListEntry, done chan bool) { + f, err := os.Create(entry.path) // TODO: path separators + if err == nil { + reader := self.dpa.Retrieve(entry.key) + writer := bufio.NewWriter(f) + _, err = io.CopyN(writer, reader, reader.Size()) // TODO: handle errors + err2 := writer.Flush() + if err == nil { + err = err2 + } + err2 = f.Close() + if err == nil { + err = err2 + } + } + + errors[i] = err + done <- true + }(i, entry, done) + } + for dcnt < cnt { + <-done + dcnt++ + } + + if err != nil { + return + } + for i, _ := range list { + if errors[i] != nil { + return errors[i] + } + } + return +} + +// Upload replicates a local directory as a manifest file and uploads it +// using dpa store +// TODO: localpath should point to a manifest +func (self *Api) Upload(lpath, index string) (string, error) { + var list []*manifestTrieEntry + localpath, err := filepath.Abs(filepath.Clean(lpath)) + if err != nil { + return "", err + } + + f, err := os.Open(localpath) + if err != nil { + return "", err + } + stat, err := f.Stat() + if err != nil { + return "", err + } + + var start int + if stat.IsDir() { + start = len(localpath) + glog.V(logger.Debug).Infof("[BZZ] uploading '%s'", localpath) + err = filepath.Walk(localpath, func(path string, info os.FileInfo, err error) error { + if (err == nil) && !info.IsDir() { + //fmt.Printf("lp %s path %s\n", localpath, path) + if len(path) <= start { + return fmt.Errorf("Path is too short") + } + if path[:start] != localpath { + return fmt.Errorf("Path prefix of '%s' does not match localpath '%s'", path, localpath) + } + entry := &manifestTrieEntry{ + Path: path, + } + list = append(list, entry) + } + return err + }) + if err != nil { + return "", err + } + } else { + dir := filepath.Dir(localpath) + start = len(dir) + if len(localpath) <= start { + return "", fmt.Errorf("Path is too short") + } + if localpath[:start] != dir { + return "", fmt.Errorf("Path prefix of '%s' does not match dir '%s'", localpath, dir) + } + entry := &manifestTrieEntry{ + Path: localpath, + } + list = append(list, entry) + } + + cnt := len(list) + errors := make([]error, cnt) + done := make(chan bool, maxParallelFiles) + dcnt := 0 + + for i, entry := range list { + if i >= dcnt+maxParallelFiles { + <-done + dcnt++ + } + go func(i int, entry *manifestTrieEntry, done chan bool) { + f, err := os.Open(entry.Path) + if err == nil { + stat, _ := f.Stat() + sr := io.NewSectionReader(f, 0, stat.Size()) + wg := &sync.WaitGroup{} + var hash storage.Key + hash, err = self.dpa.Store(sr, wg) + if hash != nil { + list[i].Hash = hash.String() + } + wg.Wait() + if err == nil { + first512 := make([]byte, 512) + fread, _ := sr.ReadAt(first512, 0) + if fread > 0 { + mimeType := http.DetectContentType(first512[:fread]) + if filepath.Ext(entry.Path) == ".css" { + mimeType = "text/css" + } + list[i].ContentType = mimeType + //fmt.Printf("%v %v %v\n", entry.Path, mimeType, filepath.Ext(entry.Path)) + } + } + f.Close() + } + errors[i] = err + done <- true + }(i, entry, done) + } + for dcnt < cnt { + <-done + dcnt++ + } + + trie := &manifestTrie{ + dpa: self.dpa, + } + for i, entry := range list { + if errors[i] != nil { + return "", errors[i] + } + entry.Path = regularSlashes(entry.Path[start:]) + if entry.Path == index { + ientry := &manifestTrieEntry{ + Path: "", + Hash: entry.Hash, + ContentType: entry.ContentType, + } + trie.addEntry(ientry) + } + trie.addEntry(entry) + } + + err2 := trie.recalcAndStore() + var hs string + if err2 == nil { + hs = trie.hash.String() + } + return hs, err2 +} + +func (self *Api) Register(sender common.Address, domain string, hash common.Hash) (err error) { + domainhash := common.BytesToHash(crypto.Sha3([]byte(domain))) + + if self.registrar != nil { + glog.V(logger.Debug).Infof("[BZZ] Swarm: host '%s' (hash: '%v') to be registered as '%v'", domain, domainhash.Hex(), hash.Hex()) + _, err = self.registrar.Registry().SetHashToHash(sender, domainhash, hash) + } else { + err = fmt.Errorf("no registry: %v", err) + } + return +} + +type errResolve error + +func (self *Api) Resolve(hostPort string) (contentHash storage.Key, err error) { + host := hostPort + if hashMatcher.MatchString(host) { + contentHash = storage.Key(common.Hex2Bytes(host)) + glog.V(logger.Debug).Infof("[BZZ] Swarm: host is a contentHash: '%v'", contentHash) + } else { + if self.registrar != nil { + var hash common.Hash + var version *big.Int + parts := domainAndVersion.Split(host, 3) + if len(parts) > 1 && parts[1] != "" { + host = parts[0] + version = common.Big(parts[1]) + } + hostHash := crypto.Sha3Hash([]byte(host)) + hash, err = self.registrar.Resolver(version).HashToHash(hostHash) + if err != nil { + err = fmt.Errorf("unable to resolve '%s': %v", hostPort, err) + } + contentHash = storage.Key(hash.Bytes()) + glog.V(logger.Debug).Infof("[BZZ] Swarm: resolve host '%s' to contentHash: '%v'", hostPort, contentHash) + } else { + err = fmt.Errorf("no resolver '%s': %v", hostPort, err) + } + } + return +} + +func (self *Api) getPath(uri string) (reader storage.SectionReader, mimeType string, status int, err error) { + parts := slashes.Split(uri, 3) + hostPort := parts[1] + var path string + if len(parts) > 2 { + path = parts[2] + } + glog.V(logger.Debug).Infof("[BZZ] Swarm: host: '%s', path '%s' requested.", hostPort, path) + + //resolving host and port + var key storage.Key + key, err = self.Resolve(hostPort) + if err != nil { + err = errResolve(err) + glog.V(logger.Debug).Infof("[BZZ] Swarm: error : %v", err) + return + } + + trie, err := loadManifest(self.dpa, key) + if err != nil { + glog.V(logger.Debug).Infof("[BZZ] Swarm: loadManifestTrie error: %v", err) + return + } + + glog.V(logger.Debug).Infof("[BZZ] Swarm: getEntry(%s)", path) + entry, _ := trie.getEntry(path) + if entry != nil { + key = common.Hex2Bytes(entry.Hash) + status = entry.Status + mimeType = entry.ContentType + glog.V(logger.Debug).Infof("[BZZ] Swarm: content lookup key: '%v' (%v)", key, mimeType) + reader = self.dpa.Retrieve(key) + } else { + err = fmt.Errorf("manifest entry for '%s' not found", path) + glog.V(logger.Debug).Infof("[BZZ] Swarm: %v", err) + } + return +} diff --git a/swarm/api/api_test.go b/swarm/api/api_test.go new file mode 100644 index 0000000000..81156afcd8 --- /dev/null +++ b/swarm/api/api_test.go @@ -0,0 +1,205 @@ +package api + +import ( + "bytes" + "io/ioutil" + "os" + "path" + "runtime" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/swarm/storage" +) + +//TODO: add tests for resolver/registrar +// will most likely be its own package under service? + +var ( + testDir string +) + +func init() { + _, filename, _, _ := runtime.Caller(1) + testDir = path.Join(path.Dir(filename), "../test") +} + +func testApi() (api *Api, err error) { + datadir, err := ioutil.TempDir("", "bzz-test") + if err != nil { + return nil, err + } + os.RemoveAll(datadir) + dpa, err := storage.NewLocalDPA(datadir) + if err != nil { + return + } + prvkey, _ := crypto.GenerateKey() + + config, err := NewConfig(datadir, common.Address{}, prvkey) + if err != nil { + return + } + api = NewApi(dpa, nil, config) + api.dpa.Start() + + return +} + +func TestApiPut(t *testing.T) { + api, err := testApi() + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + defer api.dpa.Stop() + expContent := "hello" + expMimeType := "text/plain" + expStatus := 0 + expSize := len(expContent) + bzzhash, err := api.Put(expContent, expMimeType) + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + testGet(t, api, bzzhash, []byte(expContent), expMimeType, expStatus, expSize) +} + +func testGet(t *testing.T, api *Api, bzzhash string, expContent []byte, expMimeType string, expStatus int, expSize int) { + content, mimeType, status, size, err := api.Get(bzzhash) + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + if !bytes.Equal(content, expContent) { + t.Errorf("incorrect content. expected '%s...', got '%s...'", string(expContent), string(content)) + } + if mimeType != expMimeType { + t.Errorf("incorrect mimeType. expected '%s', got '%s'", expMimeType, mimeType) + } + if status != expStatus { + t.Errorf("incorrect status. expected '%d', got '%d'", expStatus, status) + } + if size != expSize { + t.Errorf("incorrect size. expected '%d', got '%d'", expSize, size) + } +} + +func TestApiDirUpload(t *testing.T) { + t.Skip("FIXME") + api, err := testApi() + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + bzzhash, err := api.Upload(path.Join(testDir, "test0"), "") + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + + content, err := ioutil.ReadFile(path.Join(testDir, "test0", "index.html")) + testGet(t, api, path.Join(bzzhash, "index.html"), content, "text/html; charset=utf-8", 0, 202) + + content, err = ioutil.ReadFile(path.Join(testDir, "test0", "index.css")) + testGet(t, api, path.Join(bzzhash, "index.css"), content, "text/css", 0, 132) + + content, err = ioutil.ReadFile(path.Join(testDir, "test0", "img", "logo.png")) + testGet(t, api, path.Join(bzzhash, "img", "logo.png"), content, "image/png", 0, 18136) + + _, _, _, _, err = api.Get(bzzhash) + if err == nil { + t.Errorf("expected error: %v", err) + } +} + +func TestApiDirUploadModify(t *testing.T) { + t.Skip("FIXME") + api, err := testApi() + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + bzzhash, err := api.Upload(path.Join(testDir, "test0"), "") + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + + bzzhash, err = api.Modify(bzzhash, "index.html", "", "") + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + bzzhash, err = api.Modify(bzzhash, "index2.html", "9ea1f60ebd80786d6005f6b256376bdb494a82496cd86fe8c307cdfb23c99e71", "text/html; charset=utf-8") + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + bzzhash, err = api.Modify(bzzhash, "img/logo.png", "9ea1f60ebd80786d6005f6b256376bdb494a82496cd86fe8c307cdfb23c99e71", "text/html; charset=utf-8") + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + + content, err := ioutil.ReadFile(path.Join(testDir, "test0", "index.html")) + testGet(t, api, path.Join(bzzhash, "index2.html"), content, "text/html; charset=utf-8", 0, 202) + testGet(t, api, path.Join(bzzhash, "img", "logo.png"), content, "text/html; charset=utf-8", 0, 202) + + content, err = ioutil.ReadFile(path.Join(testDir, "test0", "index.css")) + testGet(t, api, path.Join(bzzhash, "index.css"), content, "text/css", 0, 132) + + _, _, _, _, err = api.Get(bzzhash) + if err == nil { + t.Errorf("expected error: %v", err) + } +} + +func TestApiDirUploadWithRootFile(t *testing.T) { + api, err := testApi() + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + bzzhash, err := api.Upload(path.Join(testDir, "test0"), "index.html") + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + + content, err := ioutil.ReadFile(path.Join(testDir, "test0", "index.html")) + testGet(t, api, bzzhash, content, "text/html; charset=utf-8", 0, 202) +} + +func TestApiFileUpload(t *testing.T) { + api, err := testApi() + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + bzzhash, err := api.Upload(path.Join(testDir, "test0", "index.html"), "") + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + + content, err := ioutil.ReadFile(path.Join(testDir, "test0", "index.html")) + testGet(t, api, path.Join(bzzhash, "index.html"), content, "text/html; charset=utf-8", 0, 202) +} + +func TestApiFileUploadWithRootFile(t *testing.T) { + api, err := testApi() + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + bzzhash, err := api.Upload(path.Join(testDir, "test0", "index.html"), "index.html") + if err != nil { + t.Errorf("unexpected error: %v", err) + return + } + + content, err := ioutil.ReadFile(path.Join(testDir, "test0", "index.html")) + testGet(t, api, bzzhash, content, "text/html; charset=utf-8", 0, 202) +} diff --git a/swarm/api/config.go b/swarm/api/config.go new file mode 100644 index 0000000000..6657167984 --- /dev/null +++ b/swarm/api/config.go @@ -0,0 +1,105 @@ +package api + +import ( + "crypto/ecdsa" + "encoding/json" + "fmt" + "io/ioutil" + "os" + "path/filepath" + + "github.com/ethereum/go-ethereum/swarm/network" + "github.com/ethereum/go-ethereum/swarm/services/swap" + "github.com/ethereum/go-ethereum/swarm/storage" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" +) + +const ( + port = "8500" +) + +// separate bzz directories +// allow several bzz nodes running in parallel +type Config struct { + // serialised/persisted fields + *storage.StoreParams + *storage.ChunkerParams + *network.HiveParams + Swap *swap.SwapParams + *network.SyncParams + Path string + Port string + PublicKey string + BzzKey string +} + +// config is agnostic to where private key is coming from +// so managing accounts is outside swarm and left to wrappers +func NewConfig(path string, contract common.Address, prvKey *ecdsa.PrivateKey) (self *Config, err error) { + + address := crypto.PubkeyToAddress(prvKey.PublicKey) // default beneficiary address + dirpath := filepath.Join(path, common.Bytes2Hex(address.Bytes())) + err = os.MkdirAll(dirpath, os.ModePerm) + if err != nil { + return + } + confpath := filepath.Join(dirpath, "config.json") + var data []byte + pubkey := crypto.FromECDSAPub(&prvKey.PublicKey) + pubkeyhex := common.ToHex(pubkey) + keyhex := crypto.Sha3Hash(pubkey).Hex() + + self = &Config{ + SyncParams: network.NewSyncParams(dirpath), + HiveParams: network.NewHiveParams(dirpath), + ChunkerParams: storage.NewChunkerParams(), + StoreParams: storage.NewStoreParams(dirpath), + Port: port, + Path: dirpath, + Swap: swap.DefaultSwapParams(contract, prvKey), + PublicKey: pubkeyhex, + BzzKey: keyhex, + } + data, err = ioutil.ReadFile(confpath) + if err != nil { + if !os.IsNotExist(err) { + return + } + // file does not exist + // write out config file + err = self.Save() + if err != nil { + err = fmt.Errorf("error writing config: %v", err) + } + return + } + // file exists, deserialise + err = json.Unmarshal(data, self) + if err != nil { + return nil, fmt.Errorf("unable to parse config: %v", err) + } + // check public key + if pubkeyhex != self.PublicKey { + return nil, fmt.Errorf("public key does not match the one in the config file %v != %v", pubkeyhex, self.PublicKey) + } + if keyhex != self.BzzKey { + return nil, fmt.Errorf("bzz key does not match the one in the config file %v != %v", keyhex, self.BzzKey) + } + self.Swap.SetKey(prvKey) + + return +} + +func (self *Config) Save() error { + data, err := json.MarshalIndent(self, "", " ") + if err != nil { + return err + } + err = os.MkdirAll(self.Path, os.ModePerm) + if err != nil { + return err + } + confpath := filepath.Join(self.Path, "config.json") + return ioutil.WriteFile(confpath, data, os.ModePerm) +} diff --git a/swarm/api/config_test.go b/swarm/api/config_test.go new file mode 100644 index 0000000000..44bb484667 --- /dev/null +++ b/swarm/api/config_test.go @@ -0,0 +1,107 @@ +package api + +import ( + "io/ioutil" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" +) + +var ( + hexprvkey = "65138b2aa745041b372153550584587da326ab440576b2a1191dd95cee30039c" + defaultConfig = `{ + "ChunkDbPath": "` + filepath.Join("TMPDIR", "0d2f62485607cf38d9d795d93682a517661e513e", "chunks") + `", + "DbCapacity": 5000000, + "CacheCapacity": 5000, + "Radius": 0, + "Branches": 128, + "Hash": "SHA256", + "JoinTimeout": 120, + "SplitTimeout": 120, + "CallInterval": 10000000000, + "KadDbPath": "` + filepath.Join("TMPDIR", "0d2f62485607cf38d9d795d93682a517661e513e", "bzz-peers.json") + `", + "MaxProx": 10, + "ProxBinSize": 8, + "BucketSize": 3, + "PurgeInterval": 151200000000000, + "InitialRetryInterval": 4200000000, + "ConnRetryExp": 2, + "Swap": { + "BuyAt": 20000000000, + "SellAt": 20000000000, + "PayAt": 100, + "DropAt": 10000, + "AutoCashInterval": 300000000000, + "AutoCashThreshold": 50000000000000, + "AutoDepositInterval": 300000000000, + "AutoDepositThreshold": 50000000000000, + "AutoDepositBuffer": 100000000000000, + "PublicKey": "0x045f5cfd26692e48d0017d380349bcf50982488bc11b5145f3ddf88b24924299048450542d43527fbe29a5cb32f38d62755393ac002e6bfdd71b8d7ba725ecd7a3", + "Contract": "0x0000000000000000000000000000000000000000", + "Beneficiary": "0x0d2f62485607cf38d9d795d93682a517661e513e" + }, + "RequestDbPath": "` + filepath.Join("TMPDIR", "0d2f62485607cf38d9d795d93682a517661e513e", "requests") + `", + "RequestDbBatchSize": 512, + "KeyBufferSize": 1024, + "SyncBatchSize": 128, + "SyncBufferSize": 128, + "SyncCacheSize": 1024, + "SyncPriorities": [ + 2, + 1, + 1, + 0, + 0 + ], + "SyncModes": [ + true, + true, + true, + true, + false + ], + "Path": "` + filepath.Join("TMPDIR", "0d2f62485607cf38d9d795d93682a517661e513e") + `", + "Port": "8500", + "PublicKey": "0x045f5cfd26692e48d0017d380349bcf50982488bc11b5145f3ddf88b24924299048450542d43527fbe29a5cb32f38d62755393ac002e6bfdd71b8d7ba725ecd7a3", + "BzzKey": "0xe861964402c0b78e2d44098329b8545726f215afa737d803714a4338552fcb81" +}` +) + +func TestConfigWriteRead(t *testing.T) { + tmp, err := ioutil.TempDir(os.TempDir(), "bzz-test") + if err != nil { + t.Fatal(err) + } + defer os.RemoveAll(tmp) + + prvkey := crypto.ToECDSA(common.Hex2Bytes(hexprvkey)) + orig, err := NewConfig(tmp, common.Address{}, prvkey) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + account := crypto.PubkeyToAddress(prvkey.PublicKey) + dirpath := filepath.Join(tmp, common.Bytes2Hex(account.Bytes())) + confpath := filepath.Join(dirpath, "config.json") + data, err := ioutil.ReadFile(confpath) + if err != nil { + t.Fatalf("default config file cannot be read: %v", err) + } + exp := strings.Replace(defaultConfig, "TMPDIR", tmp, -1) + + if string(data) != exp { + t.Fatalf("default config mismatch:\nexpected:\n'%v'\ngot:\n'%v'", exp, string(data)) + } + + conf, err := NewConfig(tmp, common.Address{}, prvkey) + if err != nil { + t.Fatalf("expected no error, got %v", err) + } + if conf.Swap.Beneficiary.Hex() != orig.Swap.Beneficiary.Hex() { + t.Fatalf("expected beneficiary from loaded config %v to match original %v", conf.Swap.Beneficiary.Hex(), orig.Swap.Beneficiary.Hex()) + } + +} diff --git a/swarm/api/ethereum.go b/swarm/api/ethereum.go new file mode 100644 index 0000000000..1027d1e768 --- /dev/null +++ b/swarm/api/ethereum.go @@ -0,0 +1,320 @@ +package api + +import ( + "errors" + "fmt" + "math/big" + "regexp" + "sync" + + "github.com/ethereum/go-ethereum/accounts" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/common/registrar" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/core/state" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/eth" + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/logger/glog" +) + +/* +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +!! THIS IS CURRENTLY A PLACEHOLEDER (HACK) UNTIL PRC v2 +!! https://github.com/ethereum/go-ethereum/pull/1912 is merged +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +*/ + +var ( + defaultGasPrice = big.NewInt(10000000000000) //150000000000 + defaultGas = big.NewInt(90000) //500000 + addrReg = regexp.MustCompile(`^(0x)?[a-fA-F0-9]{40}$`) +) + +type ethApi struct { + eth *eth.Ethereum + gpo *eth.GasPriceOracle + transactionMu sync.RWMutex + transactMu sync.RWMutex + state *state.StateDB +} + +func NewEthApi(ethereum *eth.Ethereum) *ethApi { + return ðApi{ + eth: ethereum, + gpo: eth.NewGasPriceOracle(ethereum), + } +} + +// subscribes to new head block events and +// waits until blockchain height is greater n at any time +// given the current head, waits for the next chain event +// sets the state to the current head +// loop is async and quit by closing the channel +// used in tests and JS console debug module to control advancing private chain manually +// Note: this is not threadsafe, only called in JS single process and tests +func (self *ethApi) UpdateState() (wait chan *big.Int) { + wait = make(chan *big.Int) + self.state, _ = state.New(self.eth.BlockChain().GetBlockByNumber(0).Root(), self.eth.ChainDb()) + + go func() { + eventSub := self.eth.EventMux().Subscribe(core.ChainHeadEvent{}) + defer eventSub.Unsubscribe() + + var m, n *big.Int + var ok bool + + eventCh := eventSub.Chan() + for { + select { + case event, ok := <-eventCh: + if !ok { + // Event subscription closed, set the channel to nil to stop spinning + eventCh = nil + continue + } + // A real event arrived, process if new head block assignment + if event, ok := event.Data.(core.ChainHeadEvent); ok { + m = event.Block.Number() + if n != nil && n.Cmp(m) < 0 { + wait <- n + n = nil + } + statedb, err := state.New(event.Block.Root(), self.eth.ChainDb()) + if err != nil { + glog.V(logger.Error).Infoln("Could not create new state: %v", err) + return + } + self.state = statedb + } + case n, ok = <-wait: + if !ok { + return + } + } + } + }() + return +} + +func (self *ethApi) AtStateNum(num int64) registrar.Backend { + var st *state.StateDB + var err error + switch num { + case -2: + st = self.eth.Miner().PendingState().Copy() + default: + if block := self.getBlockByHeight(num); block != nil { + st, err = state.New(block.Root(), self.eth.ChainDb()) + if err != nil { + return nil + } + } else { + st, err = state.New(self.eth.BlockChain().GetBlockByNumber(0).Root(), self.eth.ChainDb()) + if err != nil { + return nil + } + } + } + return registrar.Backend(ðApi{ + eth: self.eth, + state: st, + }) +} +func (self *ethApi) GetTxReceipt(txhash common.Hash) *types.Receipt { + return core.GetReceipt(self.eth.ChainDb(), txhash) +} + +func (self *ethApi) StorageAt(addr, storageAddr string) string { + return self.state.GetState(common.HexToAddress(addr), common.HexToHash(storageAddr)).Hex() +} + +func (self *ethApi) CodeAt(address string) string { + return common.ToHex(self.state.GetCode(common.HexToAddress(address))) +} + +func (self *ethApi) Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, dataStr string) (string, string, error) { + statedb := self.state.Copy() + var from *state.StateObject + if len(fromStr) == 0 { + accounts, err := self.eth.AccountManager().Accounts() + if err != nil || len(accounts) == 0 { + from = statedb.GetOrNewStateObject(common.Address{}) + } else { + from = statedb.GetOrNewStateObject(accounts[0].Address) + } + } else { + from = statedb.GetOrNewStateObject(common.HexToAddress(fromStr)) + } + + from.SetBalance(common.MaxBig) + + msg := callmsg{ + from: from, + gas: common.Big(gasStr), + gasPrice: common.Big(gasPriceStr), + value: common.Big(valueStr), + data: common.FromHex(dataStr), + } + if len(toStr) > 0 { + addr := common.HexToAddress(toStr) + msg.to = &addr + } + + if msg.gas.Cmp(big.NewInt(0)) == 0 { + msg.gas = big.NewInt(50000000) + } + + if msg.gasPrice.Cmp(big.NewInt(0)) == 0 { + msg.gasPrice = self.DefaultGasPrice() + } + + header := self.CurrentBlock().Header() + vmenv := core.NewEnv(statedb, self.eth.BlockChain(), msg, header) + gp := new(core.GasPool).AddGas(common.MaxBig) + res, gas, err := core.ApplyMessage(vmenv, msg, gp) + return common.ToHex(res), gas.String(), err +} + +func (self *ethApi) Transact(fromStr, toStr, nonceStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) { + + if len(toStr) > 0 && toStr != "0x" && !isAddress(toStr) { + return "", errors.New("Invalid address") + } + + var ( + from = common.HexToAddress(fromStr) + to = common.HexToAddress(toStr) + value = common.Big(valueStr) + gas *big.Int + price *big.Int + data []byte + contractCreation bool + ) + + if len(gasStr) == 0 { + gas = DefaultGas() + } else { + gas = common.Big(gasStr) + } + + if len(gasPriceStr) == 0 { + price = self.DefaultGasPrice() + } else { + price = common.Big(gasPriceStr) + } + + data = common.FromHex(codeStr) + if len(toStr) == 0 { + contractCreation = true + } + + self.transactMu.Lock() + defer self.transactMu.Unlock() + + var nonce uint64 + if len(nonceStr) != 0 { + nonce = common.Big(nonceStr).Uint64() + } else { + state := self.eth.TxPool().State() + nonce = state.GetNonce(from) + } + var tx *types.Transaction + if contractCreation { + tx = types.NewContractCreation(nonce, value, gas, price, data) + } else { + tx = types.NewTransaction(nonce, to, value, gas, price, data) + } + + signed, err := self.sign(tx, from, false) + if err != nil { + return "", err + } + if err = self.eth.TxPool().Add(signed); err != nil { + return "", err + } + + if contractCreation { + addr := crypto.CreateAddress(from, nonce) + glog.V(logger.Info).Infof("Tx(%s) created: %s\n", signed.Hash().Hex(), addr.Hex()) + } else { + glog.V(logger.Info).Infof("Tx(%s) to: %s\n", signed.Hash().Hex(), tx.To().Hex()) + } + + return signed.Hash().Hex(), nil +} + +func (self *ethApi) sign(tx *types.Transaction, from common.Address, didUnlock bool) (*types.Transaction, error) { + hash := tx.SigHash() + sig, err := self.doSign(from, hash, didUnlock) + if err != nil { + return tx, err + } + return tx.WithSignature(sig) +} + +func (self *ethApi) doSign(from common.Address, hash common.Hash, didUnlock bool) ([]byte, error) { + sig, err := self.eth.AccountManager().Sign(accounts.Account{Address: from}, hash.Bytes()) + if err == accounts.ErrLocked { + if didUnlock { + return nil, fmt.Errorf("signer account still locked after successful unlock") + } + // retry signing, the account should now be unlocked. + return self.doSign(from, hash, true) + } else if err != nil { + return nil, err + } + return sig, nil +} + +func DefaultGas() *big.Int { return new(big.Int).Set(defaultGas) } + +func (self *ethApi) DefaultGasPrice() *big.Int { + return self.gpo.SuggestPrice() +} + +func (self *ethApi) CurrentBlock() *types.Block { + return self.eth.BlockChain().CurrentBlock() +} + +func (self *ethApi) getBlockByHeight(height int64) *types.Block { + var num uint64 + + switch height { + case -2: + return self.eth.Miner().PendingBlock() + case -1: + return self.CurrentBlock() + default: + if height < 0 { + return nil + } + + num = uint64(height) + } + + return self.eth.BlockChain().GetBlockByNumber(num) +} + +// callmsg is the message type used for call transations. +type callmsg struct { + from *state.StateObject + to *common.Address + gas, gasPrice *big.Int + value *big.Int + data []byte +} + +func isAddress(addr string) bool { + return addrReg.MatchString(addr) +} + +// accessor boilerplate to implement core.Message +func (m callmsg) From() (common.Address, error) { return m.from.Address(), nil } +func (m callmsg) Nonce() uint64 { return m.from.Nonce() } +func (m callmsg) To() *common.Address { return m.to } +func (m callmsg) GasPrice() *big.Int { return m.gasPrice } +func (m callmsg) Gas() *big.Int { return m.gas } +func (m callmsg) Value() *big.Int { return m.value } +func (m callmsg) Data() []byte { return m.data } diff --git a/swarm/api/http.go b/swarm/api/http.go new file mode 100644 index 0000000000..b1cd039cce --- /dev/null +++ b/swarm/api/http.go @@ -0,0 +1,247 @@ +/* +A simple http server interface to Swarm +*/ +package api + +import ( + "bytes" + "io" + "net/http" + "regexp" + "sync" + "time" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/logger/glog" +) + +const ( + rawType = "application/octet-stream" +) + +var ( + bzzPrefix = regexp.MustCompile("^/+bzz:/+") + rawUrl = regexp.MustCompile("^/+raw/*") + trailingSlashes = regexp.MustCompile("/+$") + // forever = func() time.Time { return time.Unix(0, 0) } + forever = time.Now +) + +type sequentialReader struct { + reader io.Reader + pos int64 + ahead map[int64](chan bool) + lock sync.Mutex +} + +// browser API for registering bzz url scheme handlers: +// https://developer.mozilla.org/en/docs/Web-based_protocol_handlers +// electron (chromium) api for registering bzz url scheme handlers: +// https://github.com/atom/electron/blob/master/docs/api/protocol.md + +// starts up http server +func StartHttpServer(api *Api, port string) { + serveMux := http.NewServeMux() + serveMux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { + handler(w, r, api) + }) + go http.ListenAndServe(":"+port, serveMux) + glog.V(logger.Info).Infof("[BZZ] Swarm HTTP proxy started on localhost:%s", port) +} + +func handler(w http.ResponseWriter, r *http.Request, api *Api) { + requestURL := r.URL + // This is wrong + // if requestURL.Host == "" { + // var err error + // requestURL, err = url.Parse(r.Referer() + requestURL.String()) + // if err != nil { + // http.Error(w, err.Error(), http.StatusBadRequest) + // return + // } + // } + glog.V(logger.Debug).Infof("[BZZ] Swarm: HTTP request URL: '%s', Host: '%s', Path: '%s', Referer: '%s', Accept: '%s'", r.RequestURI, requestURL.Host, requestURL.Path, r.Referer(), r.Header.Get("Accept")) + uri := requestURL.Path + var raw bool + + // HTTP-based URL protocol handler + uri = bzzPrefix.ReplaceAllString(uri, "") + glog.V(logger.Debug).Infof("[BZZ] Swarm: BZZ request URI: '%s'", uri) + + path := rawUrl.ReplaceAllStringFunc(uri, func(string) string { + raw = true + return "" + }) + + glog.V(logger.Debug).Infof("[BZZ] Swarm: %s request '%s' received.", r.Method, uri) + + switch { + case r.Method == "POST" || r.Method == "PUT": + key, err := api.dpa.Store(io.NewSectionReader(&sequentialReader{ + reader: r.Body, + ahead: make(map[int64]chan bool), + }, 0, r.ContentLength), nil) + if err == nil { + glog.V(logger.Debug).Infof("[BZZ] Swarm: Content for %v stored", key.Log()) + } else { + http.Error(w, err.Error(), http.StatusBadRequest) + return + } + if r.Method == "POST" { + if raw { + w.Header().Set("Content-Type", "text/plain") + http.ServeContent(w, r, "", time.Now(), bytes.NewReader([]byte(common.Bytes2Hex(key)))) + } else { + http.Error(w, "No POST to "+uri+" allowed.", http.StatusBadRequest) + return + } + } else { + // PUT + if raw { + http.Error(w, "No PUT to /raw allowed.", http.StatusBadRequest) + return + } else { + path = regularSlashes(path) + mime := r.Header.Get("Content-Type") + // TODO proper root hash separation + glog.V(logger.Debug).Infof("[BZZ] Modify '%s' to store %v as '%s'.", path, key.Log(), mime) + newKey, err := api.Modify(path[:64], path[65:], common.Bytes2Hex(key), mime) + if err == nil { + glog.V(logger.Debug).Infof("[BZZ] Swarm replaced manifest by '%s'", newKey) + w.Header().Set("Content-Type", "text/plain") + http.ServeContent(w, r, "", time.Now(), bytes.NewReader([]byte(newKey))) + } else { + http.Error(w, "PUT to "+path+"failed.", http.StatusBadRequest) + return + } + } + } + case r.Method == "DELETE": + if raw { + http.Error(w, "No DELETE to /raw allowed.", http.StatusBadRequest) + return + } else { + path = regularSlashes(path) + glog.V(logger.Debug).Infof("[BZZ] Delete '%s'.", path) + newKey, err := api.Modify(path[:64], path[65:], "", "") + if err == nil { + glog.V(logger.Debug).Infof("[BZZ] Swarm replaced manifest by '%s'", newKey) + w.Header().Set("Content-Type", "text/plain") + http.ServeContent(w, r, "", time.Now(), bytes.NewReader([]byte(newKey))) + } else { + http.Error(w, "DELETE to "+path+"failed.", http.StatusBadRequest) + return + } + } + case r.Method == "GET" || r.Method == "HEAD": + path = trailingSlashes.ReplaceAllString(path, "") + if raw { + // resolving host + key, err := api.Resolve(path) + if err != nil { + glog.V(logger.Error).Infof("[BZZ] Swarm: %v", err) + http.Error(w, err.Error(), http.StatusBadRequest) + return + } + + // retrieving content + reader := api.dpa.Retrieve(key) + glog.V(logger.Debug).Infof("[BZZ] Swarm: Reading %d bytes.", reader.Size()) + + // setting mime type + qv := requestURL.Query() + mimeType := qv.Get("content_type") + if mimeType == "" { + mimeType = rawType + } + + w.Header().Set("Content-Type", mimeType) + http.ServeContent(w, r, uri, forever(), reader) + glog.V(logger.Debug).Infof("[BZZ] Swarm: Serve raw content '%s' (%d bytes) as '%s'", uri, reader.Size(), mimeType) + + // retrieve path via manifest + } else { + + glog.V(logger.Debug).Infof("[BZZ] Swarm: Structured GET request '%s' received.", uri) + + // call to api.getPath on uri + reader, mimeType, status, err := api.getPath(path) + if err != nil { + if _, ok := err.(errResolve); ok { + glog.V(logger.Debug).Infof("[BZZ] Swarm: %v", err) + status = http.StatusBadRequest + } else { + glog.V(logger.Debug).Infof("[BZZ] Swarm: error retrieving '%s': %v", uri, err) + status = http.StatusNotFound + } + http.Error(w, err.Error(), status) + return + } + + // set mime type and status headers + w.Header().Set("Content-Type", mimeType) + if status > 0 { + w.WriteHeader(status) + } else { + status = 200 + } + glog.V(logger.Debug).Infof("[BZZ] Swarm: Served '%s' (%d bytes) as '%s' (status code: %v)", uri, reader.Size(), mimeType, status) + + http.ServeContent(w, r, path, forever(), reader) + + } + default: + http.Error(w, "Method "+r.Method+" is not supported.", http.StatusMethodNotAllowed) + } +} + +func (self *sequentialReader) ReadAt(target []byte, off int64) (n int, err error) { + self.lock.Lock() + // assert self.pos <= off + if self.pos > off { + glog.V(logger.Error).Infof("[BZZ] Swarm: non-sequential read attempted from sequentialReader; %d > %d", + self.pos, off) + panic("Non-sequential read attempt") + } + if self.pos != off { + glog.V(logger.Debug).Infof("[BZZ] Swarm: deferred read in POST at position %d, offset %d.", + self.pos, off) + wait := make(chan bool) + self.ahead[off] = wait + self.lock.Unlock() + if <-wait { + // failed read behind + n = 0 + err = io.ErrUnexpectedEOF + return + } + self.lock.Lock() + } + localPos := 0 + for localPos < len(target) { + n, err = self.reader.Read(target[localPos:]) + localPos += n + glog.V(logger.Debug).Infof("[BZZ] Swarm: Read %d bytes into buffer size %d from POST, error %v.", + n, len(target), err) + if err != nil { + glog.V(logger.Debug).Infof("[BZZ] Swarm: POST stream's reading terminated with %v.", err) + for i := range self.ahead { + self.ahead[i] <- true + delete(self.ahead, i) + } + self.lock.Unlock() + return localPos, err + } + self.pos += int64(n) + } + wait := self.ahead[self.pos] + if wait != nil { + glog.V(logger.Debug).Infof("[BZZ] Swarm: deferred read in POST at position %d triggered.", + self.pos) + delete(self.ahead, self.pos) + close(wait) + } + self.lock.Unlock() + return localPos, err +} diff --git a/swarm/api/manifest.go b/swarm/api/manifest.go new file mode 100644 index 0000000000..c1781ab7d3 --- /dev/null +++ b/swarm/api/manifest.go @@ -0,0 +1,310 @@ +package api + +import ( + "bytes" + "encoding/json" + "fmt" + "io" + "sync" + + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/logger/glog" + "github.com/ethereum/go-ethereum/swarm/storage" +) + +const ( + manifestType = "application/bzz-manifest+json" +) + +type manifestTrie struct { + dpa *storage.DPA + entries [257]*manifestTrieEntry // indexed by first character of path, entries[256] is the empty path entry + hash storage.Key // if hash != nil, it is stored +} + +type manifestJSON struct { + Entries []*manifestTrieEntry `json:"entries"` +} + +type manifestTrieEntry struct { + Path string `json:"path"` + Hash string `json:"hash"` // for manifest content type, empty until subtrie is evaluated + ContentType string `json:"contentType"` + Status int `json:"status"` + subtrie *manifestTrie +} + +func loadManifest(dpa *storage.DPA, hash storage.Key) (trie *manifestTrie, err error) { // non-recursive, subtrees are downloaded on-demand + + glog.V(logger.Detail).Infof("[BZZ] manifest lookup key: '%v'.", hash.Log()) + // retrieve manifest via DPA + manifestReader := dpa.Retrieve(hash) + return readManifest(manifestReader, hash, dpa) +} + +func readManifest(manifestReader storage.SectionReader, hash storage.Key, dpa *storage.DPA) (trie *manifestTrie, err error) { // non-recursive, subtrees are downloaded on-demand + + // TODO check size for oversized manifests + manifestData := make([]byte, manifestReader.Size()) + var size int + size, err = manifestReader.Read(manifestData) + if int64(size) < manifestReader.Size() { + glog.V(logger.Detail).Infof("[BZZ] Manifest %v not found.", hash.Log()) + if err == nil { + err = fmt.Errorf("Manifest retrieval cut short: read %v, expect %v", size, manifestReader.Size()) + } + return + } + + glog.V(logger.Detail).Infof("[BZZ] Manifest %v retrieved", hash.Log()) + man := manifestJSON{} + err = json.Unmarshal(manifestData, &man) + if err != nil { + err = fmt.Errorf("Manifest %v is malformed: %v", hash.Log(), err) + glog.V(logger.Detail).Infof("[BZZ] %v", err) + return + } + + glog.V(logger.Detail).Infof("[BZZ] Manifest %v has %d entries.", hash.Log(), len(man.Entries)) + + trie = &manifestTrie{ + dpa: dpa, + } + for _, entry := range man.Entries { + trie.addEntry(entry) + } + return +} + +func (self *manifestTrie) addEntry(entry *manifestTrieEntry) { + self.hash = nil // trie modified, hash needs to be re-calculated on demand + + if len(entry.Path) == 0 { + self.entries[256] = entry + return + } + + b := byte(entry.Path[0]) + if (self.entries[b] == nil) || (self.entries[b].Path == entry.Path) { + self.entries[b] = entry + return + } + + oldentry := self.entries[b] + cpl := 0 + for (len(entry.Path) > cpl) && (len(oldentry.Path) > cpl) && (entry.Path[cpl] == oldentry.Path[cpl]) { + cpl++ + } + + if (oldentry.ContentType == manifestType) && (cpl == len(oldentry.Path)) { + if self.loadSubTrie(oldentry) != nil { + return + } + entry.Path = entry.Path[cpl:] + oldentry.subtrie.addEntry(entry) + oldentry.Hash = "" + return + } + + commonPrefix := entry.Path[:cpl] + + subtrie := &manifestTrie{ + dpa: self.dpa, + } + entry.Path = entry.Path[cpl:] + oldentry.Path = oldentry.Path[cpl:] + subtrie.addEntry(entry) + subtrie.addEntry(oldentry) + + self.entries[b] = &manifestTrieEntry{ + Path: commonPrefix, + Hash: "", + ContentType: manifestType, + subtrie: subtrie, + } +} + +func (self *manifestTrie) getCountLast() (cnt int, entry *manifestTrieEntry) { + for _, e := range self.entries { + if e != nil { + cnt++ + entry = e + } + } + return +} + +func (self *manifestTrie) deleteEntry(path string) { + self.hash = nil // trie modified, hash needs to be re-calculated on demand + + if len(path) == 0 { + self.entries[256] = nil + return + } + + b := byte(path[0]) + entry := self.entries[b] + if (entry != nil) && (entry.Path == path) { + self.entries[b] = nil + return + } + + epl := len(entry.Path) + if (entry.ContentType == manifestType) && (len(path) >= epl) && (path[:epl] == entry.Path) { + if self.loadSubTrie(entry) != nil { + return + } + entry.subtrie.deleteEntry(path[epl:]) + entry.Hash = "" + // remove subtree if it has less than 2 elements + cnt, lastentry := entry.subtrie.getCountLast() + if cnt < 2 { + if lastentry != nil { + lastentry.Path = entry.Path + lastentry.Path + } + self.entries[b] = lastentry + } + } +} + +func (self *manifestTrie) recalcAndStore() error { + if self.hash != nil { + return nil + } + + var buffer bytes.Buffer + buffer.WriteString(`{"entries":[`) + + list := &manifestJSON{} + for _, entry := range self.entries { + if entry != nil { + if entry.Hash == "" { // TODO: paralellize + err := entry.subtrie.recalcAndStore() + if err != nil { + return err + } + entry.Hash = entry.subtrie.hash.String() + } + list.Entries = append(list.Entries, entry) + } + } + + manifest, err := json.Marshal(list) + if err != nil { + return err + } + + sr := io.NewSectionReader(bytes.NewReader(manifest), 0, int64(len(manifest))) + wg := &sync.WaitGroup{} + key, err2 := self.dpa.Store(sr, wg) + wg.Wait() + self.hash = key + return err2 +} + +func (self *manifestTrie) loadSubTrie(entry *manifestTrieEntry) (err error) { + if entry.subtrie == nil { + hash := common.Hex2Bytes(entry.Hash) + entry.subtrie, err = loadManifest(self.dpa, hash) + entry.Hash = "" // might not match, should be recalculated + } + return +} + +func (self *manifestTrie) listWithPrefixInt(prefix, rp string, cb func(entry *manifestTrieEntry, suffix string)) (err error) { + plen := len(prefix) + var start, stop int + if plen == 0 { + start = 0 + stop = 256 + } else { + start = int(prefix[0]) + stop = start + } + + for i := start; i <= stop; i++ { + entry := self.entries[i] + if entry != nil { + epl := len(entry.Path) + if entry.ContentType == manifestType { + l := plen + if epl < l { + l = epl + } + if prefix[:l] == entry.Path[:l] { + sterr := self.loadSubTrie(entry) + if sterr == nil { + entry.subtrie.listWithPrefixInt(prefix[l:], rp+entry.Path[l:], cb) + } else { + err = sterr + } + } + } else { + if (epl >= plen) && (prefix == entry.Path[:plen]) { + cb(entry, rp+entry.Path[plen:]) + } + } + } + } + return +} + +func (self *manifestTrie) listWithPrefix(prefix string, cb func(entry *manifestTrieEntry, suffix string)) (err error) { + return self.listWithPrefixInt(prefix, "", cb) +} + +func (self *manifestTrie) findPrefixOf(path string) (entry *manifestTrieEntry, pos int) { + + glog.V(logger.Detail).Infof("[BZZ] findPrefixOf(%s)", path) + + if len(path) == 0 { + return self.entries[256], 0 + } + + b := byte(path[0]) + entry = self.entries[b] + if entry == nil { + return self.entries[256], 0 + } + epl := len(entry.Path) + glog.V(logger.Detail).Infof("[BZZ] path = %v entry.Path = %v epl = %v", path, entry.Path, epl) + if (len(path) >= epl) && (path[:epl] == entry.Path) { + glog.V(logger.Detail).Infof("[BZZ] entry.ContentType = %v", entry.ContentType) + if entry.ContentType == manifestType { + if self.loadSubTrie(entry) != nil { + return nil, 0 + } + entry, pos = entry.subtrie.findPrefixOf(path[epl:]) + if entry != nil { + pos += epl + } + } else { + pos = epl + } + } else { + entry = nil + } + return +} + +// file system manifest always contains regularized paths +// no leading or trailing slashes, only single slashes inside +func regularSlashes(path string) (res string) { + for i := 0; i < len(path); i++ { + if (path[i] != '/') || ((i > 0) && (path[i-1] != '/')) { + res = res + path[i:i+1] + } + } + if (len(res) > 0) && (res[len(res)-1] == '/') { + res = res[:len(res)-1] + } + return +} + +func (self *manifestTrie) getEntry(spath string) (entry *manifestTrieEntry, fullpath string) { + path := regularSlashes(spath) + var pos int + entry, pos = self.findPrefixOf(path) + return entry, path[:pos] +} diff --git a/swarm/api/manifest_test.go b/swarm/api/manifest_test.go new file mode 100644 index 0000000000..558bdfb51b --- /dev/null +++ b/swarm/api/manifest_test.go @@ -0,0 +1,61 @@ +package api + +import ( + // "encoding/json" + "fmt" + "io" + "strings" + "testing" + + "github.com/ethereum/go-ethereum/swarm/storage" +) + +func manifest(paths ...string) (manifestReader storage.SectionReader) { + var entries []string + for _, path := range paths { + entry := fmt.Sprintf(`{"path":"%s"}`, path) + entries = append(entries, entry) + } + manifest := fmt.Sprintf(`{"entries":[%s]}`, strings.Join(entries, ",")) + return io.NewSectionReader(strings.NewReader(manifest), 0, int64(len(manifest))) +} + +func testGetEntry(t *testing.T, path, match string, paths ...string) *manifestTrie { + trie, err := readManifest(manifest(paths...), nil, nil) + if err != nil { + t.Errorf("unexpected error making manifest: %v", err) + } + checkEntry(t, path, match, trie) + return trie +} + +func checkEntry(t *testing.T, path, match string, trie *manifestTrie) { + entry, fullpath := trie.getEntry(path) + if match == "-" && entry != nil { + t.Errorf("expected no match for '%s', got '%s'", path, fullpath) + } else if entry == nil { + if match != "-" { + t.Errorf("expected entry '%s' to match '%s', got no match", match, path) + } + } else if fullpath != match { + t.Errorf("incorrect entry retrieved for '%s'. expected path '%v', got '%s'", path, match, fullpath) + } +} + +func TestGetEntry(t *testing.T) { + // file system manifest always contains regularized paths + testGetEntry(t, "a", "a", "a") + testGetEntry(t, "b", "-", "a") + testGetEntry(t, "/a//", "a", "a") + // fallback + testGetEntry(t, "/a", "", "") + testGetEntry(t, "/a/b", "a/b", "a/b") + // longest/deepest math + testGetEntry(t, "a/b", "-", "a", "a/ba", "a/b/c") + testGetEntry(t, "a/b", "a/b", "a", "a/b", "a/bb", "a/b/c") + testGetEntry(t, "//a//b//", "a/b", "a", "a/b", "a/bb", "a/b/c") +} + +func TestDeleteEntry(t *testing.T) { + +} diff --git a/swarm/api/roundtripper.go b/swarm/api/roundtripper.go new file mode 100644 index 0000000000..3dad7d04ef --- /dev/null +++ b/swarm/api/roundtripper.go @@ -0,0 +1,22 @@ +package api + +import ( + "fmt" + "net/http" + + "github.com/ethereum/go-ethereum/logger" + "github.com/ethereum/go-ethereum/logger/glog" + + // "github.com/ethereum/go-ethereum/common/httpclient" + // "github.com/ethereum/go-ethereum/jsre" +) + +type RoundTripper struct { + Port string +} + +func (self *RoundTripper) RoundTrip(req *http.Request) (resp *http.Response, err error) { + url := fmt.Sprintf("http://localhost:%s/%s/%s", self.Port, req.URL.Host, req.URL.Path) + glog.V(logger.Info).Infof("[BZZ] roundtripper: proxying request '%s' to '%s'", req.RequestURI, url) + return http.Get(url) +} diff --git a/swarm/api/roundtripper_test.go b/swarm/api/roundtripper_test.go new file mode 100644 index 0000000000..e0b15658dc --- /dev/null +++ b/swarm/api/roundtripper_test.go @@ -0,0 +1,50 @@ +package api + +import ( + "io/ioutil" + "net/http" + "strings" + "testing" + "time" + + "github.com/ethereum/go-ethereum/common/httpclient" +) + +func TestRoundTripper(t *testing.T) { + serveMux := http.NewServeMux() + serveMux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { + if r.Method == "GET" { + w.Header().Set("Content-Type", "text/plain") + http.ServeContent(w, r, "", time.Unix(0, 0), strings.NewReader(r.RequestURI)) + } else { + http.Error(w, "Method "+r.Method+" is not supported.", http.StatusMethodNotAllowed) + } + }) + go http.ListenAndServe(":8600", serveMux) + + rt := &RoundTripper{"8600"} + client := httpclient.New("/") + client.RegisterProtocol("bzz", rt) + + resp, err := client.Client().Get("bzz://test.com/path") + if err != nil { + t.Errorf("expected no error, got %v", err) + return + } + + defer func() { + if resp != nil { + resp.Body.Close() + } + }() + + content, err := ioutil.ReadAll(resp.Body) + if err != nil { + t.Errorf("expected no error, got %v", err) + return + } + if string(content) != "/test.com/path" { + t.Errorf("incorrect response from http server: expected '%v', got '%v'", "/test.com/path", string(content)) + } + +} diff --git a/swarm/cmd/bzzhash/bzzhash.go b/swarm/cmd/bzzhash/bzzhash.go new file mode 100644 index 0000000000..d4df5fb50b --- /dev/null +++ b/swarm/cmd/bzzhash/bzzhash.go @@ -0,0 +1,38 @@ +// bzzhash +package main + +import ( + "fmt" + "io" + "os" + "runtime" + + "github.com/ethereum/go-ethereum/swarm/storage" +) + +func main() { + runtime.GOMAXPROCS(runtime.NumCPU()) + + if len(os.Args) < 2 { + fmt.Println("Usage: bzzhash ") + os.Exit(0) + } + f, err := os.Open(os.Args[1]) + if err != nil { + fmt.Println("Error opening file " + os.Args[1]) + os.Exit(1) + } + + stat, _ := f.Stat() + sr := io.NewSectionReader(f, 0, stat.Size()) + chunker := storage.NewTreeChunker(storage.NewChunkerParams()) + hash := make([]byte, chunker.KeySize()) + errC := chunker.Split(hash, sr, nil, nil) + err, ok := <-errC + if err != nil { + fmt.Fprintf(os.Stderr, "%v\n", err) + } + if !ok { + fmt.Printf("%064x\n", hash) + } +} diff --git a/swarm/cmd/bzzup.sh b/swarm/cmd/bzzup.sh new file mode 100755 index 0000000000..dc6490ad70 --- /dev/null +++ b/swarm/cmd/bzzup.sh @@ -0,0 +1,46 @@ +#! /bin/bash + +INDEX='index.html' +port="8500" +delimiter='{"entries":[{' + +if [[ ! -z "$2" ]]; then + port="$2" +fi + +if [ -f "$1" ]; then +hash=`wget -q -O- --post-file="$1" http://localhost:$port/raw` +mime=`mimetype -b "$1"` +wget -q -O- --post-data="$delimiter\"hash\":\"$hash\",\"contentType\":\"$mime\"}]}" http://localhost:8500/raw +echo + +else + +[ -d "$1" ] || exit -1 + +bzzroot="$1" +[ "_$1" = _ ] && bzzroot=. + +pushd "$bzzroot" > /dev/null + +(for path in `find . -type f` +do +name=`echo "$path" | cut -c3-` +[ _`basename "$name"` = "_$INDEX" ] && name=`dirname "$name"` +echo -n "$delimiter" +hash=`wget -q -O- --post-file="$path" http://localhost:$port/raw` +mime=`mimetype -b "$path"` +if [ "_$name" = '_.' ]; then +echo -n "\"hash\":\"$hash\",\"contentType\":\"$mime\"" +else +echo -n "\"hash\":\"$hash\",\"path\":\"$name\",\"contentType\":\"$mime\"" +fi +delimiter='},{' + +done +echo -n '}]}') | wget -q -O- --post-data=`cat` http://localhost:$port/raw +echo + +popd > /dev/null + +fi diff --git a/swarm/examples/album/add.png b/swarm/examples/album/add.png new file mode 100644 index 0000000000000000000000000000000000000000..6d87680603e65a28a5a4c61eaf741c3ea654b527 GIT binary patch literal 129 zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdz4^J1zkch)?uQ_r7C0qiR|Gr;& zXG>qpfdlX3Y9)AFee^@6bADR{Xq}C@D-Kl8z;IXX&gY}nhLubV4F66t*0}(MB)As{ XF$(gSIfYuy0V(lx^>bP0l+XkK7q}(Y literal 0 HcmV?d00001 diff --git a/swarm/examples/album/back.png b/swarm/examples/album/back.png new file mode 100644 index 0000000000000000000000000000000000000000..d05b45d9bd130af04157570b915780d20a9073e6 GIT binary patch literal 388 zcmeAS@N?(olHy`uVBq!ia0vp^5V!L}5I};u8FPv(%iY|@b)X~;(f#<_bs-w_RuxcKiiVetbQP4 z*}A1=Mc>LBtsf}rOiyV6Ze! zM5iLy+{rW6RzIR>W!R(#vQh^m4d&-Is4Un0wK>7GQ&{8F1>EMFXD_?Ddd}sL ze+KTRUma?L`af~adR6K+!HwrlQ`N7_k9w+vIoy=~bDiF=dv4YC+Jg~G6lB9b{8W29 grPWHj+Lht`ZkN^&^K?xCV0bZjy85}Sb4q9e0FytQB>(^b literal 0 HcmV?d00001 diff --git a/swarm/examples/album/cut-left.png b/swarm/examples/album/cut-left.png new file mode 100644 index 0000000000000000000000000000000000000000..f24692daa3880047ac14bce2760e68bb1a8fc770 GIT binary patch literal 221 zcmeAS@N?(olHy`uVBq!ia0vp^AT}2V8<6ZZI=>f4u_bxCyDx`7I;J! zGcYi}0Aa?h)j`=nLG}_)Usv|KT*Bg3M)T_Hdx1h(o-U3d5|?|=1#%s7;9)&*b6Zg9 z_nNqK(o^F6HA1e;XYmrueIUqmSedoFr^1zM*9lJMWsLr7D)Jrrr)fM?4v^>Ny}o04 z2cP!=!+^WWfwg^YQoG*-9@^!&Z($4X^mvW>Kix%XcVuQbzhD-;ExKjaxA%vEwla9S L`njxgN@xNA55Y_F literal 0 HcmV?d00001 diff --git a/swarm/examples/album/cut-mov.png b/swarm/examples/album/cut-mov.png new file mode 100644 index 0000000000000000000000000000000000000000..9744870681bfff97b86fcdb6e42d45aabb6b9358 GIT binary patch literal 197 zcmeAS@N?(olHy`uVBq!ia0vp^JRr=$1|-8uW1a&kwj^(N7l!{JxM1({$v_d#0*}aI z1_tgOAk1jDNkSYb$X?><>&kwYn@LEaloaenK>gPabEJkIgIWKTYo zIrvoOf4u_bxCyDx`7I;J! zGcYi}0Aa?h)j`=nLG}_)Usv|KT*BfqCR+|g&H)PfdAc};NL=ncW6js#z{7m;r0Vx6 zGW<>lw|9njvz*AgW5ZjKtvBnC1FwP%%bLUmEYp5CP8XQ)vC*&bmwVs~4Fm38*M)l> h`aE10zGW?~U_QT7t=;`^W+KpJ22WQ%mvv4FO#oH3K5hU2 literal 0 HcmV?d00001 diff --git a/swarm/examples/album/cut-top.png b/swarm/examples/album/cut-top.png new file mode 100644 index 0000000000000000000000000000000000000000..61b0fd59788f663c64b1cccacabf558da28979e8 GIT binary patch literal 205 zcmeAS@N?(olHy`uVBq!ia0vp^AT}2V8<6ZZI=>f4u_bxCyDx`7I;J! zGcYi}0Aa?h)j`=nLG}_)Usv|KTp|o?QZenyM}R_6o-U3d5|?|=S#vcw@UR~E82;kb z*PJ~ID?DcNwzys~d3f;2<%bRjgQ`6%kG2%AS=id>Hb*i|q>^Ka-tuc^h&N!X?vqbITNpfD{an^LB{Ts5w9rWI literal 0 HcmV?d00001 diff --git a/swarm/examples/album/data.json b/swarm/examples/album/data.json new file mode 100644 index 0000000000..20efd5d4f0 --- /dev/null +++ b/swarm/examples/album/data.json @@ -0,0 +1 @@ +{"blur":[600,336],"data":[{"blur":"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD//gADKv/bAEMAAwICAwICAwMDAwQDAwQFCAUFBAQFCgcHBggMCgwMCwoLCw0OEhANDhEOCwsQFhARExQVFRUMDxcYFhQYEhQVFP/bAEMBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAAcACgMBEQACEQEDEQH/xAAVAAEBAAAAAAAAAAAAAAAAAAAEBv/EACEQAAAEBQUAAAAAAAAAAAAAAAABAgMFCBESFSIlMVNh/8QAFwEAAwEAAAAAAAAAAAAAAAAAAAIDBf/EAB8RAAIBAgcAAAAAAAAAAAAAAAADAQIFBhESFBYxUv/aAAwDAQACEQMRAD8AQcxWXhlzcAaStB66uHQy8FF4mfXGekzItq56JpcwDN6thb57AvJneQ2FB//Z","file":["imgs/apron.jpg"],"img":["imgs/apron.jpg",[1600,1059]],"thumb":["data:image/jpeg;base64,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",[169,112]]},{"img":["imgs/bekas1.jpg",[1600,1059]],"thumb":["data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD//gADKv/bAEMAAwICAwICAwMDAwQDAwQFCAUFBAQFCgcHBggMCgwMCwoLCw0OEhANDhEOCwsQFhARExQVFRUMDxcYFhQYEhQVFP/bAEMBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAHAAqQMBEQACEQEDEQH/xAAcAAABBQEBAQAAAAAAAAAAAAAFAgMEBgcBCAD/xABHEAACAQIEAwUEBQoDBgcAAAABAgMEEQAFEiEGMUEHEyJRYRRxgZEIFTKhwSMkQlRigqKx0fAzU5MWJVJVkuFDY3KUsuLx/8QAHAEAAgMBAQEBAAAAAAAAAAAAAgMAAQQFBgcI/8QAMxEAAQQBAwIDBwMEAwEAAAAAAQACAxESBCExQVETInEFMmGBkaHwFFLRIzOxwQbh8UL/2gAMAwEAAhEDEQA/AKStJ6Y+xL51QTgpbdMWou+zX6YpUlrS36YiopwUvLbFq04tLi1EsUu+Iop+XUKSToHsVJ39MJeaGyYwAlWino4EeONSVDbEAeH4Y55JNlbQBwpUkMSg2Bv9kBl/Hy9+EkkJgAKiy0cJR0iT9K12bbrg8rFFVQBsIZHK6VDFUa2kXBN+u/44zh4Lk0tNItTz62YXKgHkOWNZ7LOp0C2IPMHp0wJVhEqemWYDUPD5nphLjSaB3U8ZZYoV3Veg6YVmmYpTZb4gVIJPMDrgc1ePZOx0YUL0POxGKLlYbSeXWgsDtgDSIGkuNh1Zue22AIrhWFNp3tsC1v5YUUwJ+7eeARrz2uXm2wGPWhwXnMSvmoip5YvIFCR3XRR8tsTJClrSemDtRKNOIwS3IYEvDRZRBpcaCcWmEiBl3BxA4EWFRBBopxaUjBWqTscJjIIwJ3RDZS48z0EA7WI/n/8AuOUXCza6ABoJNdmRMYtdmNyAOV9QH44XI8dAmMakfWrK7qPEUQbDqwJv+OKBANK+RZXZKlY2aYSFIyniFrG5NrYB4pxd8EbXEtARSlaMKoD3lAZmuLL6D+fPEYXB2LgqeGkWEqozNKOnjB0tGwIJthsri0WlMAJop3h/OFAjiEgaJ7ad78htfGSI2Rae/bhWRa2TVsRa3TGnAdUrMr4V0wbfcDrgcArzKkLVseZwGKLJKFTrPP5YotpXkll1Cgjn6HAUiBCSK8w7XIGKLLV50vvrj9s4rwiq8ULI6PMxJTwDufGzWO3TBid7gAgMbRZIRyMwTIGEfPpjoNyLbtY3FoNEJ+Okp3G8e/ocHbweUPlPRcmhpKWLvHRgtwPvxT5XMGRKjWNccQFCztKURyRQlVmQBhdrXFt/wxg1Mz6LQdwtcMbeTwofDU0GYAwCRSxchbcuVyP54VoddncZ33/7R6rS15gjj5YY/I+7HcEgK5RZSaeksh239cW51CwoBZCGVVHeWOVW8P2WF8cXUGzm0rqw7DAoZLOxpEctplRtW/Uenyxg/UERBx5F/RavC/qEDgpqKbTT1bvIGKOdGo7k3t+AOFjUljXuJs2i8LItCmUMvtbSzOdR1gqhG197f3642wyiUlx52WZ7cAB0RijAjWNyT3Xd7lTzNzjoNo04rM4kEgKDm7x1LRLqBe+rRe2seV/T1wiUhxAHKNli7UTLLxRosQbvVYXdvCALnxEetj8sZmHEAAbhOcLNkq7U0pceCTVYbt5nHXBDlg3CkirkU7gYhjBVZpbVbSemBwARZ2upIb3t8sCQoHJqqzmKkj3YlyxUKOptfGSVwj3pPYCU3lvEWWZnRVFUtVGkUG0zO1gnrfyxmi1UcrS4HjlNfE5hAI5Ur6xyv9dp/wDUXDP1MX7x9UHhu7LP6HL4RBRtFIVvuJBvcW3Jt0vjC0jFrmlbCPM4OVnyrLdVMptZOg/746kUuLaWCSO3WiUeVLa52v64d46V4KF8UUZgoFYKHUMCRfe98YtVMSzZaoIwHKl5lLJLXKYWNiAt97XIG3y3+GOBLqHmTyrrMhaGUU7w5AKXOIYw6Hu2JIAtex07W877e7FQS+FMD2Ulj8SMrVvqjcjWhtsRbHp/1AXF8A90xLk3eIwDLe+L/UBwpV4BBVWzvLpqB3ZkdR4QWVbg3Nv6Y5ss2LsltiisUFV8zi9hiZwuqAsDY2IBJK3t5G3PljmSytY3y/nRbGRuc7zIHFVtJls2kWaIuZNtj4uh9P79edHKfCc08j+VqewCQEcFTKapqstloIJ4NBngSaGQG2tXB0tp5kkjYemHwaoh7a5QS6emm/VXB5HhMsZsgQCwbnfnY/P549R4hFgnZcTAGiF9U0cbAVPdlJ1AZzGoZnsSDbyNsQkVl1Qi7xQ6gtVwwtRhpt76n5gWO5+fLyGENfnRamubjYcrpluXiGjjAQqbbgm5x1YzTVgeCSpZpwoubADB5Ugpfezg4HJXSaqk9npZZAT4VJ2GAc8AWja2zsst4kzKqWrHsqTzzFDpWLSWVR+nvtz8/X0x57VzEm28/L6rrQx7b8LNc8z36ny2N2qkaSaTu3pUBJZlt4iPIEi3kceSlD4mh4cLJojv6/nK6ezjVcKkfXr/AOZN/pj+uOfgjor0tkU7S02XQKrqsiLGkkvg9WFza3lv5Y95EXBoaQVzX4ucSCCt84Y7EM3zjLInp82ycsRfuxUnb02FsM/VNjFEIf07nGwonEvZjn/ClalNUwd+7Rd6Ho1eZCt7c1XnfpiN1kb7A6KHSvCQnYxxnxLk8dZleTy1MLkqGEgicEHcFXsenIjCpNVG4UCmMge07hUat+jb2no0vecJVryIG7qaCWJtxYC/jHS/zxy3EO9VuFhR8u7Fu0TLZGkqODM0jCyPKoEKuSSfME7YtlclC6+iP0GQcXwTVPtfDmaQX3DGjk5226e/G6GWyQ5ZJGkAEBcrBmdLVqr5bWwyaRq7ylkAII8yLXxpMjMqBSgH1uFWeMc6any1mniaMSRspYgroexsd7bf0xk1L2tHqtMOVrNnqaSuywSwzqbIoIEl11EahcjlcEj3npjlHF7bC2W5pIKrUeYyJw9mHdkJIk2lldtWpAwuot5k7+ewxlY44uATnN3C0uqFIeIsqmrKj2aKHKaKOK/iIcmTZR7vwxr07Wh2d1SvUmwG/BFM94gyPh/Koq/Nq+my6inJlDVH2ix5LbmSNrAA3x1HT4bvIC5oiB90Ko8R8b0WWlavLlfMss7lnWeK7BRYEkm3LocYH+0A11t3CaNKC2k92cZ1Jm9KXp3QUsMFxB1DbG23p541aXUmQW3gf5SZ4QOeVqPD2cQ5xRlyIoWV2QIsgNwPTnjtRaoPG+y5j9MWlCuIuKqJKibK4JVeqCFnA2CC3nywEmsZZjB3RR6d3vHhUzOu0esps47ilkiSKkVlCFr94Qv2m+dhjkT6+YSf0zQH39Vsj0sZacuSi69ptJV8GSVssbTVERCTRQLf963Rfxxqg1/jwZPHmHNf5SnaUskpvCzDM+0SmIlCVFKiVKyKyyPqZfDsVP8AYuDjFLM36rayN3KrPFuT/WPeVJrIUCWlZ9OlmbSCE3G3nueRB5HHPkhDtyUYcRtSqnd0v63F/px/1xmpncfRHZXqTivhiu4mrNEFTS0dBENo0LKzseZYgfcMfSZ4m6p/v00dB/K8RppX6RmzCXHqenyVdk7IalWYJJAx571kqk/C2MTtDp+Nj8yt7faGpPNj5BFMg4W4k4Pnkly2uWnede7dWrHkDLsdNnB22BsMY36HTA0G7+pWlutnIyy2HwCpPE9HxNwjSxzvm2c0VXVzSOBRZ9U6Nm8gwAuLGwGODrWxaeMObYcfiSNl3NK+WV5a7doHUUd0DyvtO49FTPDS8YcTRvDpvqzqe2/KxL7443jvG9rq+GD0RGj7fe1eMlaTjniXUu1jXlgT6Fr4S7W4mnOU8NvZEYvpQ9tlJtDx/nz2DNaRqdjYf+qPfDWanLr9lDGOynUP00O2qlZUqOMa/XtdZ6KlksPMgRjyw8agg0UHhhWuj+mH2ztcGsy7OEtqIOTwudNubDYj5W9cbBm7skHEIin0x+Mkplkznh3hhoJWIWSryFNEum2qxV97al+YxTjhs5WAHe6oU30tcvqKKtqpezbgTMxTx99VqmUtE0cZv+UYhzZdjvhHjN7JvhHlVqf6Y3CVTLVvUdiPCs8lJ+ayS0tZUQsgQXCgqpKgBtvfhlgHcISC7qgMvbb2KcY0cIzHsLiWF5hWh6Hiyrju+m2rUyjmNiL2I53xWTOyrAqrce9sHZdw7QCXgXhPiPgzNmqllFM/EMWYZe6b6wIXLNELHYoAL2BBGFOa0i6pXR7qPkn0kckrqVcsehdqqqOmUwRNTMwtbd1IDbe7ANzjstNBUQDyFovBnZ7wfxU8Fa2c8S5WqqFk+rqmGWeHp4TKh1X2BuQd+eM+VO8xPyVkZNoIDnnAvYlDWVprO1XtGyycEidKrI6ZwpHMtpG9udyet8acomjdx+hUAcOgVfzLsw7EIp1cdsHFUc628VdwbUSMLjqImW23piEDo4j1CsZEcD6ofnPBXZ0vDvdcOdsctbUxSF+7rODq6m1xnVs0hvcgsN+g/RNtiGIJt/2IUIdzX3CyOGvr5sqlienjg7qopl1bBmuwDILDoOZB3ufPCSQQLRUrVxCsFLNHT02YzVFCZ3YRMbKDcDpz9/oMc+R7yKs1urLG8hL7yP8AWP8A4/0xn8WVV4Y7r2DRce5UFciSpqbknUlA4AHly+/mcfeRMwbn7A9F8mMT+nbqR1+a7U8XZU7CQQ17PcarUjgHGPU6eHUHqHHsCtul1U2mGxaWjuR+bqUnG1FG4Ps1Yx0kKGprAe65xg1OkkxLY22el3f5/wCLo6fXR5h0rgO9VXw/KVZ7VMxpOJ+G6M01JPTVEMq6XljFrm6sbjz2OPMe0NJLFpTJK2sTze9E1XyXodHr4pdSI4nXY46WOvz+iySmoRKjq6KXRQQzpy9fdjxpk3IXpOVG9l9lRW7wa11fZ5dCD+OM76J35UACn0+VtXrGisskxA5kADqb/Dc4Y0cBRcNHRCoMjSBmkA069iQvkPU9MOzLDiOFRI6qFU57LkeZx10aV9NV0ehfb6FGTWgS4IdW+0pGk3G40jffHodMGzRNeQLH1+q50hLXEAqyDtDybjfJ2y7iCkjqhPIZoM7yZI/aIZVXT3k0HhSTUbqwXQxFt7gEaZohK0Dg9EuN5jJKFdq3DmZ5Jw6q5Jk8U3B8aRVC1uXhp2nluQslSukPEVK7B1CqQLMTy5EsL4rbS6bJmvADV52414ZquIeOONKPLqNYKzJqhpD3JKyVKs26m3kBsPhexxqq7KzA0BazcUyzldcSyADSNa7geW/L3YWT0RqVFElKAEjEZ66QBfFcqkQo5kp62GV9RVGG6mzW62OJYrZUVvfZB2oNlddCl2jo3Zk0qfEp9ffjNIyxfVDwVu1RDS5xHVZhkdLQzcURwd3R1lSgleFSd2RG8HegXCu4bTc2G+FZOaMhyivaljc9NKe8QRJ7RrOtZpPEDybVfe/n64S2R5O6sO6JyRO7o17yijSQWV31GxHv5b4W+ajZVOcOqiy5bS1NOokyyHVr2cMLi/M/yxZleRYQkmlFfJqeb8jLQi8ZDKyDa1+u/P1wDZJf/oIQX9VI/wBnKb9Xi/i/rhn9X9oTKevRcLqk91FtS7C+P0A+mgr4m0klPSusiGwve23liW13mCui00eUqKnB2bf9o8zi3AEoWuICBcbzGm4fqn1EIhRgVXUTuOQHrjyv/ILd7PkAF+7/AJC9L7DbWtjI+P8AhZUvEFIryK/tMZ+0xkhYAi++5HpyOPkAiduT1X1EMdW6TWSyVVMZKeUM5NvGoW5J5XwHhu68ow2uUxXZpVUML0sDwidheou+4UbiNSBvvzPU7dN9DGNApx9Up2PUqvx8S1kYlUQB11E+JW8J53GLcyIblyC2Vam5ZU5lVVc9PTrErzlfy0kzFImBBsF8+m/nhkU0cBLo3G/soBHIaKlTwVLPC2b5Tl7TqAy5hAAkyHpuN/v8sdWP2qwC5B9P4WV8AHuuRZZ80omhajzPMqOSCTvYKmlnaOWM7XKvzZTYXVtStbcHHQGr0mqFZUfoswbJFvVhTsu4Y4U4wkas9u+quKqh7z1ywJRyVEu/jli1CCZi7MxeJoXNxdG5FLoHuB3rsR/sdfstLZgD3WWdsf0duI+HKp87o8rNXBK/5waEFomZr2k3CmItbdXCgk3Uk3uoxPPx/O3/AKmZt6LMM64Dz/J7S1OTVwh0i08dO0kZut+ag2texvaxGF4ObyiDgVW1mQjSJE1KdwSL4HhRGeHMyqoqxmy9ZqmWwDJSoZSPK4UG2/XpiiMlRC9O9hOY8SZpXUVFTZZXVebvULHArJpHI6i7vYABbk3PIHYkYU6F7qDWmj8EOQb1Xq/tF+hDW5/wVLxFkOYQVfGscfeVGVwRhYKoW3RHY3MgHItZW5G1wQEmkc0ZN978+/56CHhxsLxvWwS5RVTRyvLA8Z7t6epj0mJxs0ZU7ggggg8vfjmSWw1V/JMJKjzyiGMtGKx0fxARwEi/KwsDbEwlcLrZWQ7lDcxzTu0hVjKGkNl75GU/E22388A4PI3B+iAh3ZR/aqz/ACh/1pgPDP7vuf4VYuXoOfi7LKRi81fTUyJfV31Qi7eY3x98drYS42aA5shfJW6KagACSeKBQpu2TgijRu+4ryvUv6IqUJA/4rA8vXGNvtbSNAuQLa72PrXE1GaUSv8ApCcGZVTrKcylqIWIs9PSzSAgm17hLdD7+mFv9vaJrgA7L0COL2BrZLtob6n/AEu59xjT8RcPCajjmjWogE0Us7KoK31AW1ar26EX3x432r7aZqIHRtBsjqeOq9boPZL9G8SOcNuw+Sxvi3iuoy6rC1NNXygp4RDSOY28vFy648YwzSb2K9V6E5XQKi0mbZ/S5O2ZDLu8zOaUex5dLq1CE3BnJA0q1/sqxBtdhci2NLYGh3vqCN13ulZXlvaDxG9VHS0WXUsmiNgskoQKCSCW2JvYW/ng/AiHJTDGXdE9T9l3aaXL1mYplsd9zRwrV7HyAKkW8rYIQwVwhENK3cM9na0FU6ZpxzUTTSxrEYaqlFPexv4Q4uPmeQwUrWyV5U1kbWlXml4MyZI2jmzlqpWNtDva59Dz+WECKMGwE3Ac0kfUXCtAncCWWcq2w7x5SG8hvtisGDorAQXMYeG+6leTNzA6yGMrO3duGP6FtXPcbHfGiIuZ/aPy/wCkp0bD7wVLzfjWDhOvnpE4oaNYozBZIpS6xsLmO0d7r5qdjflfHVEsrQMhv+fdYjGxxtvCP8B1VVxZlkTcOMM2l7syVFHSzWqKQ3NxJFIBdfJlupHlbGgSueLItKwANBIzvKYKCqoKjP8AIaeP6ygaajlzCjC+0Ij6WZGFwwDMASORIvzGB8RoO4pFie6KZPnVFl8fd0VFTU69RSFLfLwnGhkjRwVncxx5VgyrjmTKKmCWFp42gmE6AxtbWL77XHIkfHGnMPbVpbWlpul6j7KfpQ0qCnjq6kU7G3+LuD88KdEHbhEHUUB+l92KcIdquSN2mcPju8+heEZlS0U5VaxNQQTBV/8AFQHcgXZBY3KKRx59KKulsjka/wArgvJlXwpTwIY6iauiQC2g1Dx2HzGMPhDjdbCAo0mYUFGzpHV1PeINOl5Gbrba+2FufHGLJO3qhsBQPrGD/mNT8/8A64X48P7igzb3UZ+CKTi+tjqp8taonSMQII6VdIjUsVW5G32jvfCcpnbdFHse4o7S9nCtTvKvsqRRkhUnCgrc8tCi3xvizE875bIxFRXaDgiCCrWOqqKpe7AAWioz4veW2P4emKGnDj5zaLwWnkIvDw3lKorClqHLEELVVFinPeyW3t64e2JjTdIgA3ZHIMkyFKNXqKBXVejFivx1Hl54vBjjxwmX2QzOOK+H8jACS5XQRoSpMpW426eMbc8Mxc4+VqHIAKnZp2z5NSkNHnMkjgAA0lMZHA6jUAR88CYdQ73QB6ocx3VezHt0oXcPFSV+YG32pVWPVvtdWP4YKPSzA256EyBUrPu0+uz6FImWSjVWL3pKh4wb3Fig2IsepPLpjeyIN6pbnEqpwcRVUMypT11YZV3EUUzN/Bci3ww0taRuENnurPwR2nV/B/FcddX1NZBHpKyM2oSQ9Q6psQfcOR9MMhLInXSXK1zxQO63PtU7ZOHOOeyJpZa+Gs44yF4I8orqDKlkl9mlcCpWepCXQrGSyliNxtcnGiZ8bTbKy/OEmNjzyNl5yyasyGQas1ObtLbdImjWFmJ6sA0nqTz+OMJy6LYK6q25BlGQ1dRA2VceQZLUKPAKjXFO7k8ypdbLa4tzsdzzuPiPb0V4NK3Th+OZuDsoy/Naw59X0BmWOu71ZEVJGVm7pdIMeplVioNrqNyRfGWRxlPmTWta1tAKYuQZfUquuIbCw1+K3zvhGNe7t81MWlDJeHqLLGPeTSHvDdNBZbediDY/LGmETPJDDaQ8MYLco9LlNU1UFpHkMcj7RSEG9z0Pr5euOg2LVdAPqsrpIeqJZ9lWfcI1dPHm8dVRTpqBp9TxGORTYhkJ8DAMDvzVwQSDjDPqZYzibo9vzZaGsZyApOWcUUcftlRnr5jXRmlZaeKCsb/GuNBOoG6AarjSxPTHnfaelm1vhmKTA3uTuS3ewPj2W+KRkNhwsdviqZJSjN5TKZYm3XWYYhEXNtwQNhy6Y0xQF5xJOI78n1KyuyebOwTv1fSfqknzGNn6WD9oVYN/agFL28ZXSFRTJm5jsxZVKxKxvtcG17+lrYZHBLld7KZ72g9b9IStNKXgy+GCtKgNNLMXUG99gBuPeRvvjT4B6lQvJCrNb218TVkZRZ6WIsTqmETNJf8AZJayj00nBDTt6qsio47R+KM1Z6mrz2rpcvpQDNJAkcZa/KNDpHjexHPYXY8t3CJjeApkVX8wznNOM6pppGq8y7yyrBAZamNFGwUDfYctRG5uThgAbxshJtFss7KeJqxfzbIZqWI2vLIqRKPhe/3YEyADcqYnsi9B2J8QVda9PLV5ZCUF27uqMrr710i3xwoTxnhXR4VtoPo7wKAa7NJJyeaxtoA9xAv9+KM3YI8O6PUXYhw5RFQ1LDVAdKpDPv8AvscAZHFEGhWSj4Ny+lGmmgWG2wEUSRj7lGF2SioL6t4Wy+oXu6nLqatAIIFYglAPnY4gJ6FSghh4H4fpKappxk1PBDVpomhpo9Ecg/aAIB/ni7VfBVys7DOFcw1eztX5ZIf0knMgv6CTUMMEjhyhodFXc3+jtVQL/u7OoapbbxVkJiY/vAkfw4MSg8hVgVW27I+LeH6i1EsUT3JVsrrihaw6gBT8DhT9TDYaTZ9LQcGk/H2gdoXCT91WiumvsEzOiMgHpqXSfmTiENcLApWHPR7Le26ozKSnpszop6bxgmWCFn9L20jSNx54zETMcJIjx07+qF1vbRRel7e6PL66q77LhWQUj276mdmjl22GtR4GvsVJBH347rNXbQXij2WMwUatalnHa7m3bhSZDnNVTRZJRU9EaaRZKwyuwQWjkkLA2cKCD4uRF91GOZqXGclo8vxWtjC1tIVBRUc5jnibvgVsJS5OoeY9MJw2xdunojGkKgA6iDsF2t8sFVKL60H+X/DgqUXneg7F+Lq+YLJQRUitvrqpwNv3dWNfiMCViVb8s+jXWTAGuz2CFTfw0lOSy/vMbH5YWZ2jgIgwqwU/YNwlk3sxzSsratpZRGhmm7tWbc2IjC7WB54AzO6BEGBW6m7O+HqKhgho8po44UZnjaaLvGBNrvZup5XPQW5YWZHHqiDQESp8gigVhTqsB5Ertqt7umKyUxTUqyU0ixSru2wK/wBfPE5VIjJSpW08aySSUjh9RnijVtQtbSxO5HuPTGWaEStxKIgPFFR6qV6OUrVlYYD4Ypl8SSH3jkfQ77dcZxK7T+WQeUdR/tAThzwlRyQy3s17i40743tcHAFu4RAg8JQqV7wXUjfdlG2DUtLedCp0MBp2OrbAkhosqEqHLVwowUkS6hcIT9oeYAxldqomi7Ql1KHnHEdLlU8VMYvGQL+EIqg+tx88Z3al79ohXr/CvzEWAhcdfVVcsqSSIId1V1Yaib8yBy2I3v645Ek73HLI+m9IdubXJ8ulpnhEUzrGx16oQFZ1sLC/M2HnzwTNQ9jMWj5/FWCQNgma2iqS8lR3ks06keFxuwtsFvf18t/PGyDVV/c3VZ1ykPmSpHEoo5kZxZmdxeIDqd97noPLHR8R72nAC/8ASvI9OUqmyeCaOb2tu/lksfCAhCgWBFtr9cW2Bof4t2fzhDgLs8p45Bl/szRxxSUob/Elhl7t5GtYlitgxt5412jTmV5DT5LGwpZJG1KqnvGLWRBpRR+yB+N98Tk2rvalOVopCVKHXzuCR8cWhXe5/b/jxFas6MkfTX5Ei2ARJxShZdfO2wXlilAUmqo6atljkNPHK8R1Ru637trWuL8jz5YpWkSUTyx20gDmbjf3YKwonhGY1U3AHQD/ALYFXSSyU8kiCVA+k3F9rHEs9FKTz6ZI27oEsTvp8/diK1CzShWWgnjqYiYHXU6xrdr9CvUH4XxTgHCiqIsUVXoZBTd00coqqIKAnfbyE+ukC+xvc263xyG1G4FjqAvypAbRFcIfmHEFRSxpKFRgZTphhZXdV0mxJ3A3sdueKl1Ej3FrHEcfnzTMHOsNUJc3q654hHHKFv8AlFVhcb2vsPvv8MNhZI8jPdqsR0PMiIyaaRoJKd3jsbsXlBRQBe97W6XxuMTWjYIwa2C+SiJfuHqqedJybEw6109fMC3MWtvjC5jH/wBRhvpSAuN5BJp6ApUubKrq2oSaCLkciQR/LDTpGl1nhEfMVHpJhVVbUsDWluNWqJgi7872+8evliwxjZMQ359FVjLYIhLkqvKhNckOj9GPqPXDjp2EUNlCEmDLIZU7tHjSPmLNceR5/wBjGhseO6q1xqeCNpTolYLt4GLADqb4MADhUh1VQT1hMMbtTKF1pIrBgfQnofngCCSi2rdQIKLN6OdUerEpHIyAWNz5W/uwwrCToUDgOiXWT5nQpqjikrluAywldSfDYkD52HXqweIL4Qm62Q3/AGtzf/ldZ/7dsYr13dv0P8pVydlq8s24Yb777bWx0AtCcVtFiWBJO1htiK06ZS4FmFxytgUSYkzERk76j/wjniKJep5FDlFgiW/5SchVAHn54F72MFuKEmkKPEOWLIqxs9YzPpYiyoqDmevW2OZ+vy9xh/O3dLD74CHT9oEs1ZNTUkKU0Y8KyDSWve1jcgC/Ik40NfO425oCcMuSkSrmucwwy6ZGj+21iF1WO2mx9OvkMVFE9xc6Qk38VACCck3T5NXxsNdGY18dnMoXQDexW3Xck3xHQvy8vCLIgbKD7HTwU0oeKfXp56lI57n+/PAhroycWBCXPPC7k9dSe0KtNFVUai7B2JQnzG5t5Hyw0vfYGOyXk69wna7OYNEkJkWpjiUtJHSm5sDfxEdbm2/34f5S7G900kHZIy7O6OeWNaaqUTabWhAcLfkL7gne343xiGp8N2Dm9fss4kINUizpEsiPNN42AGljZj7xje2aNxDWkEpmQJS5JY5GDOp2UKCH8Qty28t8OpWmJqdJhFc/ZGw1G1/O+JShNofXZbqYJHNKjMDchrgbdATYfDAubfCnIQ/KcuzfL65jV1STQujL4AUGi9wD1uQB573wsBzTzYVC97KmLntBA0iRye0NGwEh1DwsTax6g9fjhc2oEPIKW52KK+Cp8S2KMurx3Uk9L33+7Glrg4BwRIefyrv3kfdsbhbfo264Yol/nP8A5f8A1Ni7KlL/2Q==",[169,112]],"blur":"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD//gADKv/bAEMAAwICAwICAwMDAwQDAwQFCAUFBAQFCgcHBggMCgwMCwoLCw0OEhANDhEOCwsQFhARExQVFRUMDxcYFhQYEhQVFP/bAEMBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAAcACgMBEQACEQEDEQH/xAAVAAEBAAAAAAAAAAAAAAAAAAABB//EACAQAAIBBAEFAAAAAAAAAAAAAAECAwAEBREGBxIhMUH/xAAWAQEBAQAAAAAAAAAAAAAAAAAFAwT/xAAeEQABAwQDAAAAAAAAAAAAAAABAAIDBAURIRQyQf/aAAwDAQACEQMRAD8And/zrLQzK9nBFaoGBHnZ19pCW7SmQkHXiPjoGNZhw2h+oefZ2IykignYHb6rIbhUk9lfhxr/2Q=="},{"thumb":["data:image/jpeg;base64,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",[169,112]],"img":["imgs/bekas2.jpg",[1600,1059]],"blur":"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD//gADKv/bAEMAAwICAwICAwMDAwQDAwQFCAUFBAQFCgcHBggMCgwMCwoLCw0OEhANDhEOCwsQFhARExQVFRUMDxcYFhQYEhQVFP/bAEMBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAAcACgMBEQACEQEDEQH/xAAVAAEBAAAAAAAAAAAAAAAAAAAEB//EACAQAAECBQUAAAAAAAAAAAAAAAMABAECBxESFCNSYXH/xAAXAQADAQAAAAAAAAAAAAAAAAABAgMF/8QAHhEAAgIBBQEAAAAAAAAAAAAAAQMAAhEEBRQWIVH/2gAMAwEAAhEDEQA/AIkCpj5sFuDSDMTLcJPx6Ulb++tcWOTM86NNj4IqapjrKNmwbeI9if8AI3CXP//Z"},{"stamp":4,"blur":"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD//gADKv/bAEMAAwICAwICAwMDAwQDAwQFCAUFBAQFCgcHBggMCgwMCwoLCw0OEhANDhEOCwsQFhARExQVFRUMDxcYFhQYEhQVFP/bAEMBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAAcACgMBEQACEQEDEQH/xAAVAAEBAAAAAAAAAAAAAAAAAAAFBv/EACAQAAAGAAcAAAAAAAAAAAAAAAABAgMEBQYRFBdDUpH/xAAWAQEBAQAAAAAAAAAAAAAAAAAEAwX/xAAeEQABBAEFAAAAAAAAAAAAAAAAAQIDBAYRFBYiMv/aAAwDAQACEQMRAD8AhqfGtrXtElyRqMu6QCPILcSJ31Mp9au5fIpuZNLha8COT2iOygP/2Q==","thumb":["data:image/jpeg;base64,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",[169,112]],"img":["imgs/bekas_blanik.jpg",[1600,1059]]},{"stamp":5,"blur":"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD//gADKv/bAEMAAwICAwICAwMDAwQDAwQFCAUFBAQFCgcHBggMCgwMCwoLCw0OEhANDhEOCwsQFhARExQVFRUMDxcYFhQYEhQVFP/bAEMBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAAcACgMBEQACEQEDEQH/xAAVAAEBAAAAAAAAAAAAAAAAAAAEBv/EAB8QAAECBgMAAAAAAAAAAAAAAAECEQADBAUGEiEiM//EABUBAQEAAAAAAAAAAAAAAAAAAAIE/8QAHREAAgIBBQAAAAAAAAAAAAAAAAIBExESITFRYf/aAAwDAQACEQMRAD8ABZMSmVpBYoCB01mM0T6VVt5zALmxwVCcdu6UgCp4Ab0MK6OgW+H/2Q==","img":["imgs/hangar_inside.jpg",[1600,1059]],"thumb":["data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD//gADKv/bAEMAAwICAwICAwMDAwQDAwQFCAUFBAQFCgcHBggMCgwMCwoLCw0OEhANDhEOCwsQFhARExQVFRUMDxcYFhQYEhQVFP/bAEMBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAHAAqQMBEQACEQEDEQH/xAAdAAACAgMBAQEAAAAAAAAAAAAEBQMGAgcIAQAJ/8QASRAAAgECBQIEAwQGBQgLAQAAAQIDBBEABQYSITFBBxMiURRhcRUjgZEIMkJSodEWYpOxwRckM0NTgtLhGFRVVmNyc5KV4vDx/8QAHAEAAgMBAQEBAAAAAAAAAAAAAgMAAQQFBgcI/8QAOhEAAQMCAwMJBwQCAgMAAAAAAQACEQMhBBIxE0FRBSJhcYGRocHwBhQyUrHR4SNCkvEWYlPSFTOC/9oADAMBAAIRAxEAPwDXEGbrNUzCqocyZphczVUtLGqC3IIBLADjoCPrjhAAUsojfxldA/HPUpRnNHSUTO9DFE0fEVLJVoy3H+sHH4gWPPYY1DMYYCe5JLRd3mi8tzTZDJWPTiqkI81Wp63dIOOjBbEn64Go4kwNBxCJrB2qb7UrA8jM5AlIM8VZTEoqkcKrEkH8yPpgAA7QItE/yTMkl2ItPSej7p7DayccWIIH4Wxoa2LpbjJhE1ksKxo600y7rgyJt4YdGYLYj8D0wTiYuULRfRB/aLy1HlR15kcReeISm8hr2vcgjntzc2wotIEQmggXlSUdRL5S+dDFmEMcisriQllYixG0FrDsRYDAlwFgYV6jihWzenpPu71mUmNXYMilfM624Fuh7W5HS+C550hVDQi6XNnqKamrhVJmM4W67kCsFJAYqSFIAPUE3464mkgNMoSL3NljBmRV5atoVLKpDyU6EAmxIYH9ph+FxxhREHmXPqydJIhxhqDm1K+UrHWrOK6W6XSIlGVWa25o+456gfji9mahipfo3KZ2tEUxHTvU8lalfVTy5vPHT7E8vyaYGoEsZIKsRtLqPpdbdwellhLRPdp47/qgDg0wO9ZU+sKzTlPSU1LTw0tA9RaOkZfivPPvHtPpb53v7nthlnS0fY9yXF5J+3emGX1ArqB56ONstknkkMUWdzBWj3H/AFIPB9VxtJX2sTibIkhxi2/7hEKkDLcTuCM+1W2CNopM6kPKiZjDGTYgt6vaxBA5BFiOmBZSDyTVJcfAJpqlkbIBv1TxMwGaFfh8yaCkNKWqIKJDI6SX/YlUc8Wvdee4HJxtaYMDXoWQtJElEUFJU5THP5ckOVZYm55WzOqkmkqbrtJKi4QHcL2v2uOBh4d82qWWxYaLCWCo1dNRU1MJKehWKTynMjPWJNxtur+h4S3RksAWUEJzjoMcwDMBJ37gfz6usTmvBgmPE/0qRozxXzrwp1LFqHT2Y1ubVEm6ISLcU0o/aimiJurKeqSEMpHHc41vbnGR8Njdv9HiLFZGnIQ9mZxO/d6HTcL9A/AP9JDIPG/Ko4l8vKdTxRb6vJpJldltwXjYf6RL9+ouNwBxy6tI0zxHFb6dUPEGx3iZW3r4Qnr8GKPLBLWiPzoQ5tZSDcFgCB0t3xma4uY2d3ktjmhr39KdSZVLGF2SROUBZlDKDb355xZcJJ7EABgN7UP9lVVQHlWmLSSNa6KGsPlbEAEBs6K81y6EfGmaZW/3seYUq9LMkqL8z0tgsgNiFRdvVgy/VNS0d5KzzQpVtspV+h4vcYIU2zogkhSVWu6iJ3LwwP6vMGyPYWb5lSCfxxbqQ1UBIsgU8QbwiNo2F0ZTabeVubg3dSbj26YUaAJsfXYmh8I6k11Tbg89O8ERIawjsXbuSyNz9CLYWcOYkH13KZ7xvTjL9VUcspMTyCYIUhV6tgj7uTcMQD178jscKdTc34vopmB0UslFXVaxvUTpLOXDvTqPL+RKm4DG3sb/AFxQ1O4IrCIUwrzlzV0LytHIigtTyLtXgdm5UqRbqPr8izSBHghyzr4qE1FJVzwRTxbQImVkiTeu3sWY3Bt8r2F/a2BaD6+6LS6yp6WSVzXVojrTC3lQSxvaWIXuoEgHPf8AWW/Psb4jWwcrd+715K3G0nVT5dVCgjky7KJUpayd/OkgAUzSB+d21rq1jcH5EEEWIwWa8uED12hLLZ0ujF25hUZjujWpNkbfXtekjkVeTYkgN3uvfqcDmNg0T06eu5EGiJcY8fXemsLCpanLTSZsfh1lhip4l8tWB5KSkbRzyL/hfB3fOY93mqkM0HenNEYIYI4KSt+HllJaWCmqd1TKtr3Yk7ePUD26EEcjDwwNtMBAXudciSim1dBQ1MSfZqJAj7ftCWTe7WW24Ei7cWB57WvwMHmA3R1qg0m8z1Inzq3Noo8xzOapq1ikWeh8mpakp4jb0vvsJA3UHp7Wsb4aHlohomUstBN7Ql81PTVGZZbR5zW0kkRaSOqpKKBWo3D3IkqQqbkkS+4TAhCb7lW4YMbVEW13ak9XV49aU6naDcHsHr1ZUak01n+j80psz09Spp/MaWSRkl3moqlVCVFRBICzSQuLkMdpsbMGucdAPz2eS7wb5Qe/oWB1PZn9OG263ecq7/8ATd8Uf+/+W/8AwsX/AB4P3Uf8Z7/wke9H/kH8fytYS+FdNW5j9qQ6yyuW8iu5aHy7ldoJ4awvb2748qyrUYyHUzv3/hepeym51n+H5XlT4QV3k1ElPm+VVpeJkUQzm/PTj/ng/eRPwkIBRPzBKqDwy1Hlz0qvQxyotfFIzRyqfuwRc9etr8Yc2uxzt6A0nALsZ80y16p4qOVmy9DtvwVH09vxx2c+Hdo8Lk5awElpUr6L0rnMaNOKGRutpo0/j88EKVN0QR3oTVe3UEKr51+j/pHUDNHFldDDMHZQ6RWY2F/2SOOfrizhrwFBiCBK1xqH9HHT1CJnko6umEfeOocW+diTxjO6g5oT24iSqHm/hBTUUU8+X11a0aAD74JIQDbvYYzEuFwnBwIhVKr8MqqFy8GZRSbTYCSJlJ+VwSP4YVn4hNmVXv6RZjkFVLTNKJo4JWXbL60FjY2B/wCWIWBwlMCsFD4gU+YWo6iGBI2cvIlR94g+kfHP+9fr1wh1LeimLJ4lfEweWmf4Wnc7FQHzYmf96wBZDbrcduTgLix+yrW4WULJHDTIrMtPDd2np23RgjgkkG6kHoL+3GLzzIUg6qN6xRAkgpxskkBD04As377XHXrwbHnvi5O/d661IA0KkfOXeGqZpI6mk2Amd2JnjINwdzHctu3pYAE24OLy6evqqRtNNNXmoqaWrqasxJGvwgUteI8MPUQrE9bgjoeAcVlJMqw4AQrTkdFLmkYpMrjaKWCX4dYVlaSU35UKsQ3C1zxcnpe+Him4SNPBJ2gN9Va6XR+opFiXNKVaXdPtapdUo2VlW7bnqXHVR1234tybYYKYkn8oDUS2ppssyPNA9Xn9FMZZXAKTS10aJ6uLDYnYEXa3IscQlk3Mq254sF9L4n5HSyD4GozGWOWQGUxGOnLABdxsgdhe1lu1+TfoML2lPUHwhO2NU2IXreKuUZfUxrlOhsvkpoXm21NbLNPUxpItpDHJM33e7i4Cgd7XscaDij8LR3nXsQtwejnEA9Xmq/8A5RH9qX+xo/8AgwXvP+vruRe5u+ZVuuyWni0zmj09LtYB1JaAWtfjkdfrjjbRxICMNCqVOONpiTjpdRYYa290BsEDAJ5anylZ4ZnltF5TkC9+OQwOHGGjNuRAzZMct1BqGPYtJm1ZSxFjvaSscC3FuCTfvg3NYNQgDjuKb5jrvUGnNG1+eS6grqhKPcTE0sYVwLW5ZGI/LC2sa94ZGqI1HATKcZd4haykmkSLNUMSkMDUUqNwyg8lQvPNuLYYKYBkWQ5y6ykr/GPX+WStDUUuVZjGVIDBZEDA9b+o2xMxBgPPepDTq0IB/wBJZFhEOY6Dy0CRARLQVrMrrfjrGLi4PfjFlr9GvPcqGTUtWNH49aWqK1zU6YrKWCTabU1QhKkewLAfngBTq/MO5EcnBa9z1NM5xnFdU0OZV2XU08skiRVlJ5zJc3sWjbm5v9MObnDQH3KhLZ5uiTnIYpGZaevpJhew3Fo78fukdfri83QqUtLT5vl1XTRU9QJaiQF6enhlEkjgEA7EB3dSOnuPfEIB3Ku1X/TOn9XZlO6y0BoZorPK9RKKQxqTtLSeZsWwsSb36HuMUaNrFDtL3Tysy/SOnykmZ67yxK2FPLmXJZmzCSIggFZI6YbA1je2/kDjEyNaYcfX1Ul7hIChOuPDzJqnfQ5PnuezQ3fzSKahic3O5rDzZRwRz6eSb8YoPYLAIjSebkwsq3xqjkoZGy7R2RZeAlmapjmzKdD15eYhbjsdg6dMG5/ypbafzG6Lq/F7X2c0t31BXxxSMA4y9o6MAkdLQhbWHYW9/c4QXyRFloyNaSHJO0T1z/F1dTNVzW8vz5JWZyLD0sbk3PsevXnAgDQn12lXngy0R66AnuTZRlmYwXAXcq2Z5QxN+w2ix/n29gAyix9dyIvebj13ppHklEg2XKWuQ+3y93y9V7D53Fu/vi22Nh4fdC55dqfH7I6kzGioKepoJ1imDqFEcsm8q4vtNhfaw3cH8GuLWeZAJG/iR9AhZBe2ePA+ag+Ck9/4DGaV2sq15DDWCjeMVUqxSAqUDk3/AI++FZL6LkEgCVnHSiniVXs7se/bD2tISSUYrCIRmOGFHWRbSlbWF8W9kgyra6CEoEVoNpsF3A3Xr3BwwgpcwiKmiq/s+SlUqaOQ7xFIA6uO9wQQe1x7+2MxnNO9PBblhNcnrosuWSHMWValzcbiLEAWHy7YaHEhAYmyXZ9nC1QVYvvVBBIVrAj2vgiJMoZVVioIKWhpaGnhKU1PEIkWRt5sL9TYX6+2IS5zi470UgNyhA1mS0ssZugQ/wBUWwwEhAU10tkOVVVDmGWvk7ZlnUwSamzH7QeJaaPgNGYbFJOV3Bj6hyAQDgX1Qy7tFYaTotl0tLp/SeVTSDQ+U1GYRQsJKvN6+qq43vzcU6+VGCACPx74AYlsgNCIU5EyiW8UtTQDyMuz6m0xTblPwWm6CloEUgWB3IhkBt7Pits4otneAJVFzfLKPMpTV5jNUZ1WCN9lTmlRJWSqdoJ9crMRzyeeT88CXkkklHkedBHcFTmhppYo3WCNImACC143AHHqtdTa17ixvjRBSi6LSjaKnCOQisJU5v5n3gt7G/qHzxR4IJRlfDC1BVTXiWoaFh50YHIK/qn+Vvw74kdHrvVtN9UwomqKGqV4TsLot4StxIOO5Xjv1/A4BrebomVnc83TyGrSpG9JJ1qNuzyX45vyLbfV7269/mCgsFvXglyHWPrxUcExWcVFLMaaqKkMCNwcdxz1B+Y+vTdg5Lxfz/CUQG6eX5VgyzMYa9RuMdPWqbhlQFm+YZv7/wA/fAuYR/X3KIGT+fsEZPKI12+aFa9hCkoBYk8mwb63H5e2BLy0Fpd4jyT6bZeDG/pTX4tP3kxmyFdrO3gVW8nyerzmtjoqGiFVU3LiNdoJUdSL2v1GPS1OSq1Jud7hHWfsvHe+0zYSn+U6NymKpEmf5jNBZvVQ5UqPJH/VaVvQCOhCq1j3x8+5Q5ep4V5pYZm0cLE/t8p7F3KOGdUAc8wFsBarwciovg6jQ1VWKb75Z84maR/rbaB9ALY8q/l/lUulrQO3yy+a2DCUo19d6jMfgjLD5Y0fm1MtgLU+dSi1unU4r/IuVG3LR4f9UXulOCAdVj9jeCFREkf2ZqiCMG+1MzD35vb1C+IPaflEGTRn+P4Q+5M+b6oWbw+8F619xzXWFNf3amk/vTD2+1ONA52G+n/ZAcE35lGPCDwhmFota6lp/wD1aCnf+4DGge1df92G9fyQ+4/7eu5RnwA8PauJpabxHr4477d9Rkl1B7AlXHPyw8e1RAzOw7o6j+UPuTpjMEum/Ro0xVEim8VsuHPSoyWYH+EmHU/ayg7Wi7uP/VUcFU4hDD9FTyKgzZb4r6eDFNhvBUwEjnqRf3w1/tJg3603euxHTw1Rmqjm/RYzqoSQDWukK4ldoZ8zlU9P60RxGe0eAnnSOz+k00asWCEzvwE1BkBiEa5Rm25CxXK8xSbZbqWBCkC3fvz0x6LkvE0OWajqWBMuESDA103xuWHEVBhGB2IkDqJ+iFk8HdVV+VTbcojAkR0ExqYlSIkcFzuuvJ5Nu98ejfyPj2OymkSeggz1XusTeVMEWFwqW6iPJIo/0WfECLKICIcg+LSML5b51EiW4/Vksb3+YH0x5jFctYLBVTh8USx41BaZHX/aeyk+uNpTuDvBsm0H6MObz5PSPLmlDl+YGO1VRy18MkSSe8MsbAhfmRfHQ96whYHCuy/+wSYqZjzHdxQaeAmsBHW001XkDoYmSKb7bh3sSLAMCBcfPr9cJGKwpMDEUz/9hGM4g7N38Uzk8C9Syu3+dafaDd/ozncX5iykj6YPa0AP/dT/AJj7Inlz3ktY7+Kree6ZrskzGXLnpzXzwqm6Sgk+IjAN+N68duh5GCNRo0cD0ggj6IIO8R1/2vqHTWZ5xLGpy+u9QFpkhf5gX7/j1xYc06H6Iucpc18Pc9Vvu6evhqE+8RnjKMR6ef1t1+RY97/iTFUDXyULDqPNQ0OU5vBIlTXwvFHA4aWU8cX/AGh25/D6dMC6owgtBuUyk052kpt9rU378P8A71wrMF08ruKu/hR4u5LqfP0y7KtMxZS9fSmR3aVn3LGwPpJTpc9QVPA649pXxoxNPKWwddfwvCOwzqILi+ez8qn6g/zOqnmiDx+ZUPHHBMbm+5rDdxe9uw/njweI9mGvqVDRfYc6443iRa39rq4flnnNpVGQdJH2SzLauXN9yinkgqFAZ4ZXAcA37W+R/LHHb7OVqglrx3Fdl+ObTMOCr+YeI1Bl9fX0TUVe9TRlA8ce0lyxt6B3tYk4T/jWJccrXAnqKP35kZjonVNnTtUw08uWV9HUSR+Z5VTsRluAyqw7Fgbge3W1xiD2XxjbktHeh/8AIUiYEqKs1bFS10lEIpGqUVn2tLGoNl3EAsVBNh0vyeOuH/4vj3NzDKR0FCeUKLTBlBUXinlUbxSVVDmhhkB9SQghCCL35t0INiRcd+DgG+zeLpO/WbZF79TcOaVtLKKbM6jJKTMshrYKg5htZkqIwjeTbiKSmkUm53epbEgWHzwnEcl16VJ9GQ4m5AkWFxDbmZ38LSs/v9E1A2DPfr08ETqDQn2BGaqqkp9PVXnrTPSPUB6SSVuEEUrH7osbBUlO0llUOCQMefwlN9Zgexsgid8gdIibb40XTe4MdBKq9BWy5tmeY5TSU+YjMqBGeqgqKGSHyLX4ZmAAJtdefUORcc46NTk+qwNccsO0hwM93jw0N1GVWkwCe5UuPUGocylSLLaP4aVnKs9TIQVHY8X/ACGOnR9nQ936zuwLQ51YWaI610j+j74cwadqUzvOZBWV5BJqJ77Uv1sCTbHvuT8BSwbYphc6sZEanjvXSlVq7KqHLzVPRTTwqOJI4BZja9hcgk2+WO7h2jE4gYVjhnImOA0k8BOnFeXx1RuBpGvWMCY6SeAXOniT4OV2vNc5nnmSZmuU0lbslFHU07Mwk2gNba3QkX6cXOOPyh7Ge9VnV9sASbiCdBBvmEbty5lL2vo0AKeycQN8geH5VD1P4P5porKqnPs9+NbKstjElUKJE3zC9jt3MAg5F2PQDgFiBjy9T2ZfhQ2BzidRBA6TxPnrZelo8vYTFSKNSTGlwe77JTkunc+11QZpqnLsvmk0flEINRWhoo46dVDGQbmYFlUAHcATySSTxjceTcCx/wCqSe7xgeC1sxNWo4gWHrRWzTdD8bGPhMup2jlQKJJXEl1I6qbdxzcY3tweE0bT8U1zy74itpac0R5ZWV6OljcptZIo9oYc/re/U9cahgsMbuZ9UB2cXCttJoundfVQRA7t24Ehgfe45GNDcNh26MUDqY3KfKMk0vVrK4bLJ0prI7tWq4jAIsCd3pAbixtziOpYbQtCsPYNAndFprQNUsqvS6bqRId0ivPC4b5sLm/44SaWHbcMA7Ar2g3Sjv6GeHf/AGLpP8qbEinwCvaHpXKmU6LyHw211kOX6alWKlNJMUpZ65pqt3NywjUgnYE3MzFgAdoAJbjS15uzVeVLtrTdUdrK5gzjOtXwa1rJ1kgjy4Zk4aEShh5PxFntcA7igYj2Jt0GEUjGYOMAreylTaWOjgUXk+eZ9TZrmVWlJFA1ROzCpR/NLqCQhaM2A9IUkKRzfDQ9rCcggFR9PNqdFDS6Wz/UmqoJYaekqK2oqVZJd4S5F2ClXta59NrkerrjpYXEU6VJ7SOc7QrLWpOc5pmwXU2T/oQ63qaqHUr1FHRJOnnNlryNJU07Nyw4up6kAXNuOcYGkOdle6IWh1RoEtbquafEjwd1DpPXMz53VGaukp0eahpgrSX3uo3bjsW4UG4v9MPO1wzswdrePVkIqMrtAA0t5+aFybIdRTRNVOlDk+XxMUSmHmTTzy29O5lSwUD1HbY8AX5xirYrEPOXKSOz14JzKVIXm6tHhyk2k8y210a51TT1MUxSaCUGKXeLyq7dCe/A6A481ylg62MYXsplrgDfML29QoaTDUY8VIgjdrfRbw1t4oZdqXVWb6SrshWfKahDT1nx9nR42WzKuwg89QTe3Btjx3JFWpQwdGtWfncNJ+K3+2vfK9TUwdWvUdsGGOjT7Kzad+yMt09SZNQwzrltLEIoYazeGjUCwCTkfwcbfph1aiMS816b8rjeCLd4t9CocNUoNDapbHQ4E9wJP1Vak8PvsfMlzGGlaWkc7yrKA8V/3wCR/vKWX59se6wmJDwxtZuR5GhiCegix6tUw1WmWtcHAbx+YPeFtzJcuizDLoC/ESi+wcDHoWiQuY5xabIDVuoZcro6ChilCFquZgr8kqqKSB7kDm3sDjo+yuEov5Sx9c/HFMdkGOmJMda8H7VOcRh2H4ece3+k1TUFXlWW5Vm0QSSnmcJK7kbQrX9Q73A7fzx7F2HZVqPoHUadn3Xz6LEJtp/UMWolzCJ2hqKZZ2V/2ldGjDG/Yjk/hjHicMKIEjUecJEOBad65DovGLUGmvDSl0vQT0lPpdKeXLoKRFjljmpCXVQWUbgdhI68EA2JW+Ph+Kxbqdao4AfEe6ejRfsjkv2XwmMwtEkuk02k9DiBOsyJPalq6rXO/DWXS1Fm9dFkWXqagUCy+XUwou0lVkv64xa6hbAEWNumNNLFE03VGNJIv0269fUwVkq+zuFoV2UcTUyyYnNYzpcXaeM33iQqhq3xKky/LYaHL8+npFilfMo/s9SJ5Kl/LRZH3XvYRkBR6PWxsSbjoYY1XzUqDUW1B6oXC5Uo8mYdzaOEqc6edfM2ANxA1OkRM7lW6LWL51X5qJ8wrMrlqKAs0VXVTRyCQSKDIoL223PqA6fQjG5jXE3XnK1SmAAw8N2vX6ujdAT6jy/Ruq6DLs3Wj0vm2+CthYKYpNrvKwVypIJazkixNrdrY00KBcA58DLoTxPBYsRVYajtkLGbdCqtBpqn0xPm9KMopDNUQR089RBAGjKkpN+sV5DeWlgSOnTiwy46hs5zGTvT8FULnNyiAr3/AEEpv+rQf2C/yx52F6TN0q/eEeaxad1HlgqqGn+NkeRYqplFlIQh47ke1z9Ppj1jXZHaLxFSHUzGlk9rJqb4mdosppiHlc7yepuTis7dwTmtsLoOWaN14y2Jb9LbuBgNoTo1N2Y+ZJauGiqY4J6+GSmMd2SOIHm/fkE/TDTdKAT2m19qWnpooaDVufU1DHaMQGrl2L323J6dOB2wrMdQqDWncqxS5HWVmdNIa6SauqwFaoqDcsBua7Ek8KCxPsL4ScQ4OAG/tRFs2O5E5q1TIyLQ5nULSQgRRL5SncOpkbvuc3PsOB2ww1ntU2bY6UJNT16lVfMHYsDdHst/mLdMJdXc113KiwApYNQakilknNe1TUXKrJI6udoNlB47C3UnpjhnBYOTs2COiRdaBinuHxT1rOLxy1RlrCKpelA5AE0Q9RHWxBBP5YocnUXWYfFNFcnQhWLTf6RlSM0po5HhgdwbtSlgl/6ym4tjbhaIwzTTfdp3ECJTWVGuMVBHSrHR/pT5zp7NMxpajJKPOoVlVIGo5DD5bHgqeCGF/wBrjnt3x06OJFEGnMwYuZN9BPhe6GpXotqFpOi1/wCJ/wCk1r7UGdTUWlaeLLMoJAnjmpElmWQEqziUkjaVtb0gjuD2AAUsU/F0Za82kawPLes1QsxDA1+nA+tVa/DnxrzjWOTnSmf0lRLPU0kkMgljSE0NSQLstj94OLhvT3sOtvofI2LfiamSq6X2gxcxuMd68LytyfSpEYig3KBqJ9dSgzPWGvNA1FTp/Kc1GUwSRxyFjEamaQmMKSrPdQb7haxFh0GOZy1yhiqGKdQLgQ3Qxcg+EzO5acBgcDiaIrvZfeJMA9C1/m2i84zWjqo83zGpzCplSJS11gkKqrD0hAoXhv2QPljxtVrXHaPEnsXuKeNrUaWSlUcBwk/dTZfpXM6WnmgeGpekmVQfKqLAW6gg9iO2BFUMYeab6LE6s5zg4ieKnbTeVx1MS1uTysyjgqhBS3Isymwt1698ZnYkAyQVTsS1mrSsMxyHTeZV8NXV0GcOiIYmiNbuWQHqpLXYDnsR0GFjlBotdJONYZBGqBrMkyWjjlgpsrkny0srJQ1UzOEZTuVwb/rBibe2NrOVGtaKeo17ZlK29MulouftCs2a00MmjXo6JhTrEsQ+GjPMgseD1uF6/U4rE16daiNk6Tv4rpYGrTNaXO6la/LpPf8Auxh2K7PvISbQlTHmGo0pYHLTLPNMF2lrLz6uOR35+du+O/GbReTcclO/QiswrGoJcypa6SKKsoZXaZjEU82F3bY6hupHCn34YdSArTXVa2EPaC1Vyp1FAkd1qm2dWW/X8RfCyXxAF02d4UI1bDPOuypikv0UXN/ztbCTTqHUqjG9LpdVmOZzFFGYxbletu3GEPpYkmJSHF82VqOrnynI6eKOhQ1tbGDLJL6RDAbFFN72L2DEdl2g/rHGh4exstF0xznHRJW1lCagF4lfY5s0bWAPt0xhDnt5z23ShVePiai31RTtGVmp7uw3KoYnuPz7YA1hMFslJdictokrFKqCtMgSjdLpdg3p3D2wt9RpM5UZxTTulY0uRpVyIi5dZ1J4CKTcj5nk/wAcaaTohzU8VA4AgKbM9LVBDNHR/CgAXLqpYDtcgH54rEVXOhoBCRVqOsBMpKtPU5LXRy1axLTvGDu8sXuCbOW+Vlt72Pe2OvhKbMge4An1Hco9uYQ7VG6a0zUwpMzyMZTzGYkuCe++9+o73wunRFMHM4omtcwTqic90dJWzr5MAp5gfMilklZOO49Iv0vyDhfvTKZjMVb6jI530Vo8O9KJkeQxwZlK7VPmO5R9xQL2s/7X4274e+q15BeT2/dG0tbornLTUJiHlVDp5a7QRyDz2H/7phDnNMwU0wUqk0w0tS0prwm4EABX6f4dTjk1G5jmLoWCpRLnZiYX1Zpythplk+OWoinLL5Zup4tz7j8RjLUNSmAc0gpbqdVgs6UGMiDkiaORSbgDaSV9jx8+e/0xlLzvCSWuaJcFPWZBlsVOjVUuyRiQ4IUX7Aj3uevQDFh8iAyepEzK6waPFFto/L7+Wm/zWJIBAIF/3bHn8cIziJcEwUabwC0LH/J/S/7Kf+x/+2A94o8VPdz8pWpfDxKzSuoosxFYlRFNTtDNCI2srF2br0JsSL3x76m7KSttemKrI4Jnmzx6m1BPmtZmtPSybhGKZNtygJ2hhckkdCRgX35xV0W7NoY0FFZh4dU2ZNFTrM4iqHPk+u6AcnZu23A9vf3xnDgJhay0wksWhYaCvmpIqZhURt5TxoHla5tbvze/FvfCKldw/bKxVKjmnIGyUbJomooaktW0cUcgt900FpEPbctuPx54wmtiKws0a9qz1n1ZgD7rHMaOeKfzJKVqsyHczKB6uO9ufbr74z5q7BMyUjZ4huhTGh03FV06OlI1NtO0ogADdLXHPGLzVMpLnea0MZUF3lNaLT8UNRuLxTAkkF1I8vnm47k/LGdzxSFhPZdMDRTaSRm7Ez+zomm2rVwJJe48tQNw/wAL++I6uAyXCJSH16Y5pEIr7JSlgXfOCSVO4sQD7jbz9MZqddxcWjTtWeniHNdl0CJqsklzGE1NoSARx5xufcccj6jGh2Y88hazSe4h1lLTxVuXshiphHJCDtlSMbuR3Nub4puKqU3fFHrpRRWmCQApqn7WzBi5mUy2H3kii9h2+XU9sazjcxBe6VpykaIpsrapfllXd1QMWUfIXN7YU/FNfqZlWAT8S9j0pEyFzVS7TdtjMAPytzjOHBxtKHYjNKOpctpoI18m6LawLkMCf4WxDUJjKE0NGiNaBFsG2vc3tuW/4dcQ1CLkKc0GDqpC4V9q/d7v1X4t+R5wplVxEhLzzfcgWo5sxg5eKcRm5Ze34XwRG2bx8EtwFVkCHeCmi0bNU0gqSlK77rReYtnIHW1sMZhXhktMT2yltoua2W2S6vOZUSCKSI00gsUMLB+O1yb2xnOF50FMaHfCZCh+0sy93/s1/litg3j9E7KfmPh9lpqnyakpK5VijV6hwGO9L7rc/rEcW/xx6JlYPMNBhA2sHmACm60299v3JldDGWiIkMdzw3A4NxY/jgy7KbwnSnOl2rci8uGrjMWXNIPImdhdGFrdfc8gf4Yx7octNFzjrqFjm9Y76hjSXN6evra7dNBtlRZiEYAsu23CsQu4Di9sKcBSOcOMaRuWOrT2VU1nOPkiVonilaapn2ySHl2dn3H3JF/zOLNVsCNFTqoIDhJngpGo4oghjV5iWsTGoYj62wxrWHRPDRCMq8tWgC7ZS1xc7VI2/wA8ZnPDZypZj9t1HDC0ot5ckg/8mMpe52jJQ5nbgmsWnIqnYzoQQOQ/pP05vg20XmCBARBubVEU+nqWNi81OZKdOC7SEBPne3bjAVG1GfuCx12hkFhAPSi6Y/Z7mGSDsGHm8XBFwQLC4t0OEZXZuffv+iVtXtgbl7G6AiRYgHvdSyt/PF5HNOUzC2l7Jgt7YUpjnqCCkwF+6HviNZkM/VPBBEjREwUkrybnAQ7du6OMC/1/nhzXNJFgrtKcx0hqqfaPho/KO/c7KvA+pH8MaXOcWgNAEIXCbyvp440jDRrHcH9lRZhf3GKJP7ihOsqGooo5WJ88CQC6GKm3/wB+FOYzKXSqcM7ZSsvRzupSrlSRWttBCfwI/wAMZqVejdgdfgRBKUyo1vMJv3JpNTLEpAkYqRZzvANvyxoNTIYBTXuyxcLFIaZmZI2aIKByGI3XA7fXFhz/ANxntU110U65fSVJO1C7joxF+e564DLJIBJRw1y9+w6X/wAT+P8APBx0+CmVabnzCWtgRl+CpZnsR5FOJXb5DcW5OOy6sFeUCxcsk0xmc0Uks9XXgN0V5fKDDr0Xbb5d+MZ31LTKI6WKbZDl9HSwutVQ0800bGQvVQhgGI9J9V7sOoJwplTMee1JaS4QWwps2ySDOniVKOYMeIzGwiVTz2At3PHz6jCarqtWQAAELmVKvNdoiafTNTBG0MiyjyjtZJOSvyv7YsUC5oa+IWhtNrRlARJYRQAGTZbj25xDDRc2RmALqOCoib0i5Avwgxn2tKA10lJ2jdAjp2dAhpYGjFufN5b+FsbBUkfphWXEjmhER+YkCvUOl26KpBP/ACw0ZzqiAd+5Q1DfE2INmH7vF8ZqlBpMwlupMccxF1FVyzZdIEqI96hQdrct+fOML6b6TswvKS5ppmW3TnKX+PiBETRqR1cWB/HHTpND2zFlqac10/n09JQxJOQjxDlo4iQxH198EaDSUWVCJRzyozqoliIuFB6H5i+DbSA1VQUkqX2pI7wECO25uCvt0+uMddzmyXNsO3wSXOc2ZFlhFmwnXbsaSMC5YXUD6/8A9xhbWNWxZI3zZKbUzthwt0pnRVdKFusTRnsdxP8AjiHLllrUxgblloTH4GnqiJSirIV3CSwv7W98W2kPiFkWVszChqaCOslS8Y3R9CGFwPf64a+iXgAoKtAVRBU1PlsUFOolYzMvWRgNxHbjDGtFNuWVGsDG5RuQklCrZlHLBLJEYxYIzlUI9iMA6k17g8fEOmPwqLQSHb0w+En/ANjS/wBsv88P2T/RH3RrTNA8gqJTAPIeLaUllANj+7a179+cES9wKRSFRx5w7U5mlqhTRs85chiVCt5jAXvtJ79iPncYgEAAla8pjVYxGOaV5Zw7G6kAnlWtyR2wbcs5ioJ4o+Et5lxNZB/rJL3Iw0OEEqyQBKaCnytYrx1ckshvuABsVtyR3OKzDipLRqYS6WWhqOEURbP1jK9/xPYYyNqNqbu9A14eFD8ZTBSioGNxYqCLD5AYqGVNAlCpTqiApGqHEa+s7uRySTb64e2jABBhPDA3RexUk9XILAszfmcPYCLIwE3GSeRsCybyVvu6L78YblRaKWaCMSIrKQyfrb+Pni8qoo6trW2K0dOQtgq7TbjF6K04yXOfjw0NQGiZBdY3O/cfpioVzKxrI6XMakQRgUs6/wCkVVILe/I6YIqoS77KkdTHCkpeIkOy2YDnpc4y1GZjLTdLc2dEtqzClQUU+UrC7h0JDG3S9+McytUyO4T4rJVeGOvZRfYMrMPKluWv6SxsMZThXVJNN1kRoteLJlSUFbTn0zxsAALL157m/UYNjauHEEymta4C5TdKdvIjaa4kt1v/ABONhNUAF7bIpKBrq+oYsEYSX/aYc/x6Yfsy4c66GJ1UUeYpHKscgtIeQQ3+BxAwMNghJAsivOTGvsVL/9k=",[169,112]]},{"blur":"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD//gADKv/bAEMAAwICAwICAwMDAwQDAwQFCAUFBAQFCgcHBggMCgwMCwoLCw0OEhANDhEOCwsQFhARExQVFRUMDxcYFhQYEhQVFP/bAEMBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAAcACgMBEQACEQEDEQH/xAAUAAEAAAAAAAAAAAAAAAAAAAAF/8QAIBAAAQIFBQAAAAAAAAAAAAAAAgEEAAMFBhIRFSFhcv/EABUBAQEAAAAAAAAAAAAAAAAAAAQF/8QAHhEAAQMEAwAAAAAAAAAAAAAAAAECAwYREhUWUmL/2gAMAwEAAhEDEQA/AE31/XI4MRZs2R08jyKXOVchTqLzaimvkrSNqY8bIojv6LytNl6+4VyWXoG03o//2Q==","thumb":["data:image/jpeg;base64,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",[169,112]],"img":["imgs/hangar.jpg",[1600,1059]]},{"img":["imgs/ruin.jpg",[1600,1059]],"thumb":["data:image/jpeg;base64,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",[169,112]],"blur":"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD//gADKv/bAEMAAwICAwICAwMDAwQDAwQFCAUFBAQFCgcHBggMCgwMCwoLCw0OEhANDhEOCwsQFhARExQVFRUMDxcYFhQYEhQVFP/bAEMBAwQEBQQFCQUFCRQNCw0UFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFP/AABEIAAcACgMBEQACEQEDEQH/xAAVAAEBAAAAAAAAAAAAAAAAAAAEB//EAB8QAAICAQQDAAAAAAAAAAAAAAECAwQRAAUIFCJRYf/EABYBAQEBAAAAAAAAAAAAAAAAAAQAAv/EAB8RAAEDAwUAAAAAAAAAAAAAAAABAgQFFSERFDJRUv/aAAwDAQACEQMRAD8AFPyPsWtum72xxTRIPKWBwjD6AdMSuSl4uA26NrhuCZy8hqjSuUvWkUscKYc4HrW7xM7LYRvJ/9k="}],"thumb":{"min":[150,112],"max":[267,200]}} diff --git a/swarm/examples/album/delete.png b/swarm/examples/album/delete.png new file mode 100644 index 0000000000000000000000000000000000000000..dfa04c717b3d5bdd01dd357c5fb6b586793d786f GIT binary patch literal 552 zcmV+@0@wYCP)1-C zVx^7I#v&vT5JeFz3~3V4ynvcc?G%D(EF^wuc43%1J2Th2TbLZU)t>YF&dlsCccuSb zrWrHPFKJfNgrvUghomz}r;@%(+A_wRmf8}S2ELQ7Z@^?3;9g+239zdjpy#geDd4gN zc&>}4cLNv)u1kRDx(1%7!iOkl<*qJ)!IT1f6~J@t#^A3igy(u0DsWhovON93mdEl1 z7`1#w+Ao4X3DtJIZNQp!`7`jq@q{#z``WF{Y~*-4jWNF@$r$qocrEFnq?)8TW6X`^ z?Fh}1G$ZN61#CuIF9XKOv;%FPvhO0Z)_p7d5eWgT0=39aEhNl2@CDBkf&fc6J7LXu zn>gbv&)BQE4Xw;lhm*_UMp9Sej7Ao4(8}ub62M}@oW@5H*ocHa;+%g5bZ^XB<_*bv z6V69Mbr0x0{->iJnf1n3U^tZUz*nuyD>Uv-NCQP@nDQ#F1D`yW4?t%^0spHw3%!Um zZ&kOzSYd&z#CC-RHiPi2z$4&i1@IHBBZ`%H2K+7&eg!;Df?FjX1IH!6kAUH(;8uwq qTK`+#eJ8k6q_Pi_`|)Y^PwOweFYLKGQkMJx0000P)LQib`tZe2rU=L zrR~^CNLLcGtBJWyv{wp`#GTkn$d{s-<;4A6bbcs23h2gBA)tYIEF{7Yz4yIWC^6vq zbBwvmub5N(_|)*I#7|r#PTb@ILthdel^DZKBK#VoUm6~jn81A$ev9#M36Dz5<}czS xepU6n`k|C1gs_gjEX)3d5H_lMYHDg~o&acrlchZ9WZwV)002ovPDHLkV1o27v$g;L literal 0 HcmV?d00001 diff --git a/swarm/examples/album/download.png b/swarm/examples/album/download.png new file mode 100644 index 0000000000000000000000000000000000000000..6a160c8d524f29c4de63da98eac050f41fdbc170 GIT binary patch literal 422 zcmV;X0a^ZuP)L{SihzZHaHttce6Qiw*QlXZ>$=ar-RwzD-n=>Y%{w!9DynpkXJ8SyOND{( zyax6HQ?#|$5bpyu;1rnsbJ`Y~DuF55+GP|s)Hn4-os7Qyao8;`fNfw3sOMVl1s}O& znSxbd8W>LU@4y4_`72vuhPinbaxmj);~%$IKm%BgayzuvsL)|2t|hML`*F*K=zGE3 z40Asni{3{Qy$Xzn*fIqHn!rkdb{@r>WiMq&J?^klyDAk`;0d@XaPSDM(^~8kU?Fqn z09XaAsJA6rJ_NRaiO}L)q#XfEz!yN--HTaQ??ans>PW2jQV?|}%(Rwj-^4+;1paU= Q5C8xG07*qoM6N<$g70st&Hw-a literal 0 HcmV?d00001 diff --git a/swarm/examples/album/eye.png b/swarm/examples/album/eye.png new file mode 100644 index 0000000000000000000000000000000000000000..562942a58062015c716132f39fd1dfefaf44fde9 GIT binary patch literal 525 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�U^4-pN)4aqy@k)i6A4d*Yq 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

M@rT;E{K(`&p!NM*N2GwNY%qZ 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

9Qhd^qHwDSTC$)8B#-ScQ%8Y#? zU2er%*N2~Zo5t;4vuAa?FO9^ch$&L~L~$KyOBxiCFf?aXXW`b`wYPHI-K8N5O}zX< z0Ws?W00*J2Y>mfA#lpeoLsiSCX()B#>vB#}GwhH7uB=71?pP z^j)^`PMu?Bi=xA8dfmXih7Qsq6`U9*W7@fKV4Q!rIP%*Ype?p_yPZwFLA^7C0uoyh)0vLH+`6zJ+XbqcecBG zXH&P%LP<&$$O<@$^kWA_qGyo3Ht}}tx}>qNdQ^8AjF{v90Ck>7*_?Z4OKqcHC9f?@ zZGiJo?Y`+sz=P?W1x9NqK_**@WgCkn>1ewyu%{gkHu-Hy0cVUW>J4L(qA6(>bd{BB zm$wONEn1DMK>UQj12yG&5m{Ew7cH9Ff|GT6$$bg8^H5Q4rjis^pkxI{_pQ8Ga8(mX zx6zPwgxu@uSX#a%w!F5>rV4?ae!c6rJeo-9ilkXnjoRN{w{+dI0ayVkK=U0S4x_QG zE96{=?6ah6TDGI5UfDL!muAX#g@LsyPGeyioMcw9l%R`RH62RRqO{ZQw)kXiEZ`+Y zP#_-N{p-xi^0NuH+2>B`mi8VbE(-=)ZM7w!*3wxeDv{24?ag;!gOpbyo;1fWvBTPU01g5}tq){VSUm2`+&)QrB$Js@iF4v{vR_Wl8}UP~@HGxQg^~=J;P3 z0&dP}>zy#$Tii6gm!S#X+iN>eI>|k2z898v=PIX@2R+NF<}?WUi2i`G*hb?e12IYB!xaw{-$x&EOo6twY+{8P-N^=s86L(Vi%bN z4l!PbiH$-VGK!b7O&y2twB-#=!ncr>w$c!k!(g28%|>4#sM*Y)BBk$z-M7=*Zr#h3 zq~m%9;O-_2aaD^f=MIav(GA9=+0pY#ob4Mhcwp{IR*HgH=TAC|Ef*X=T8pNCm%aZgeFL-l9wbX7GaHS!%TV$)9up(pq|V(1 zm3MWhpbKY9ND76mnE8$;=qm~2Y?u9ruDtyxR1KEY@C^xBK$$1g1FzD$akSRW8(xX* zbbGMya`kGr@|y}SJT{;t{Kg;>eZG~=k|>^3QB&G_?-Iq64?c#?ts%RT-0Z6~G>zfi$V-bYEUnK_^vO6#tbB}-aoL-Y z&k$TWv=lm~7E}Vp3c29^zrA_56mn0k6Um{zC0?e-h1|E&Ebp#u*l?Hb!$vkMgcTfP zu$uJ0jgOVISN1r)Cs=;VQnGp5XPs?iosOnZNWmwrIIl|%70S)w6p`u8YMM3u@fOj@a=y>Ns)q7S6^G1suK z3K-{_RW6Z}vcHKn7H!zLa@~GK%Y=crV2#j8_phVC+DZthE7_rHJUe~iEmf7N+udPo zAvSKbN`IPiON8TUezoXi#SRaUr7}Y?5Y9vXw212W>7PNeWSMXK>^QjzH~Q z*tpNPvLzDbmZZY;i-wp}jbAAXO7<*`-G~SCSEukSjVPn4HAv&Ntz!1~PqwqYwhU@4 zgoP&MwIm@tZs#Yry>!FHSmkUft()(7DJJo5Se2U_r&0(x0PUZ!>t1h_=i|rpOdP1! zM}l2$*7ZyuCe*fex}1_zk`HS6%-`}6Z-v_;O*CX!ct+Itc~_Trk0#wEPbmliQm^o& zdy&sI(~r!P%N%JL#5eb*+eWf`dzTwtDnm$wq$)W*a3UtXxKEp)ZjNHtRc}kw9l1rn zn1|mBFa(Gmq>lOOYq9vsO*Cg)*g10fajSL|%0=c<(nyo)8Jgtt99TN7lK7uoMdjtat)`}x+A>4xWoSv2 zrw6B~=Ld?*#rmedPDd@$Hat0W;@`jiH*OqtOuClb-4LVlDgf*_70;Usi{x#^(U0OQ zhf$`h%V*Va-*mQ_pVG>lYe0($Y&3ZK$ zEfm)cmIe9{%Wgi}Azva>BW!X_b54JP<}_V0wJbJ5LC!k+R*;*mlUD3zk*ccG;yjfU z1+RHhF||K}cx=G@6?DTQDG^ngd}HP!N5c3~{ZYRw%N zSzX^9P!SE*_^C+YpGIH*f(sZ&}hzo#7z#im^&Q1V16C{%{Y zGl}W|HPZX_9!jH5MkU?Vma*cKs5HrL z>Gr})#lRAf2j?e~+PzE|+DS<0f={yB9wooiuUk!>+oI!W^MV@M99KjovmsIm^aU@baeWcjx`&i z$MLJB-(9H%R+3OkTTz0NQ<0vS9AchaA6EzLO=`<7DR&4(&&3;cxT2*cDwM#$3hR#M zzGoBuK4y^|hT2`PS$^8`;meIk+a<=$wZgxYr4Nu}kvYwJ5b{!YWh{<5Hg2_DFe=+> zUB9~}CDKOLn^74`QciO@A9~Qn|CdTNa^v+P2xTAgk1(GxZ&-S*7gV z{YrY$F1(`hRJUGY**@A+BS*5-ZEc-wFjA;@e{JUhAebVQ;}n}f-ilhEixlsL7opq)H+5>Q$XcK& zD&HiajwB9iiyYjOvycA(V>a8wZD?p)){Hi{FTGEpey!QW0gTrEJlvflx-yMzj5@Hk zw!ClQT)O^JmiiFbmds@1G29Mo(Qw|)B$JMa{59j2bbTK~xK@_S*RQ&vbg?1O-$l5O z@XzEN;%jK(QaO^@)mse#OfOiqzkm3Wl%=M{*5RiPcppxk>u7O`q;#dTOHlGWLfS9( zJABh=2grC9#_`Vb4-!D0)ur;$ZkCY!J?%qD)a-BcWT zXXTkGKecSq#;p+1jx}d2*;|e}R<#1PxY;S+wBfaG%n^whtY;sWY>q4R-n4epS+_cl zn8m@gODa{u%x*%}gr|}6ndVJ$%{Z+Iq>AdeMWxeMc8*@U`kYF3snDdYQI#woej>T> z=7gojOwB!qL1$L9dCxxG`!<|)MQXH4OsnQI*kpa{x=_FB61CB^?}+s6K)9xD1HrVE zIEIOmNr0&UKrlV)Hzy9q8}>6!xNlI_7M(q|EYQP#Q_Q@r*aIpAnK`b!Qf#_4bi@x4 zX>TbO*0(yI;@6p$&_KW=x7)pR(`JjKY3*G2Zr0J8vemg!2`OXLL01w_PkJeh6E5{P z&j{Y6j5p*35iyyXX)#K@7H!%goI;e7#mb4buHV*8Dl@awlX@LT~ z#)FNiX>6fsQB)~XBjx(jES=>cOem$vDa3XA)Ul$3I9x(dV4RgGNC(`~D3bk$nP^LB zLZU*pnNnk|EdsMQ;Z#FzZ%9ZGkO{yvP~5a@2)F)c#VrB?Hc3$@rBkXhU6*|4T>k*M z<=h7n5D<`efF@-1&mF5eG$ylYw_8Y4qiTVM!Oy0OEe~?i-7Kj@1chZqu^YbCNQr-d zN|EINrj(f{2_$VF+Ny#*Y$Ew~Z3mlSPPzeGVn%cOQXQe@?aSfk-MXc`GGQs4bXQz^ zR0fW7R%YADcguWlSdyX$8R_0?UV!DEwnfQWS7P&wlmx5OnVcGz{+YInCHQwkzqxsD zDjZSD(vlL=)6;iyKc#0X^h5su3)Whtrk$%Sw|u(`c5t=@~lX1=nm?) zdXjFh9=To5mV~8+1HHCV73wNH!h{fgjd?yyrIT?c%%?RmYo#k&_?B)ht=&qULu2`j zEc#I5=LIC<2iCfLTco6Dq;v1Cv4**X&kEp2Bbc#up zFZASin&sy$eEcR>m2JQW)L@+R@{Ed=E$pkV%65Bn)v(RY(h`{1<;0WfNj&wKs^qUj zIx9Q3Etn16rPMa1?nrGBwMse1GI^TOFg9%6wNeyb+^0|S%Yl1T5_3(}iRgmi2-0m` zaW=7Km7&+%Dvt98K&q_~Y|qe_c&31Hn@@svT}!*wyJ`7CXWF7V?4(G9hSP44m$s$o z+TwRe>`(L*oH=Z5q--$K?j0#Z$zd&{YA!M_?~0_qO0k#B4K9zPfos%6hCA@|b8#cF>kM9Jn z8+^1UsX3f`Rj!DYx1)W9XqHF{_^W$|_L5Lqa!HbS0*0)fO(G^QnR{y6XW`1STh8NI zKd(nm_FEX6m95V)A;$c(0Ta);G$}ShRiQhp!WOlKr69y|L885v=$_u}+%!Crk=UtN zKS~6@((BDXxVm5Uq-8^&rAz++2F&ZFrJHvy8*TRzQhfuw^qO={lpVHV)GgGumX=Td z07H^7nCU+Cn8by;+7_FK+*_)IlCMaPlm3*~WU{N;bNX{X5ZlUWB<^jyg#wj(4DruB z=*iZC8tmq8^(Co?QEz319mz^aLQ)P@Jpr2Ge6jxkQ!UxhTQR6RXxEWy&B|QM${RvN zPs(PkIZJH4oTjR~ZA`SaS$Wq@B!sQQ0Va6^q!`UKsoA7x*=tm?E48q0@#b$`Y#=r* zfkG4}cQ{X9YSZRRLX-54E5{nPv2NNL7e5cN#3_{&h51D)`G6RR>H60eT+w}_2M5{9 zc$Znd)vm96)w0li#JbWOYif{V@<|~nBuN6enu~fd-H))idd}H*4Z618R2MfWm8kGG zkZ?vTMKujsstaBxxxKy%7Y?T6C2Ao0QlrH7B+qX7sh5)1Lv2~mC-DPPx3c&&TUrZn z5#|+IrAu1lKB9ZnPs?sJ%W_F*=WcbY`>TvzT( z!T$gV94dYDTyk4(iwiKU zoWbc@P8=1))|t{ZV(rniT2!>PayB;es@$X=3P~A|de_f+8KsHy74g|3>=wx8NeXTbeLW=f;;AdLD&B&_`lGH}+Fdl+ZMQc% zw$@Yx;6VNHT$!6oL6SN>J&i8H=GNNI<l;X5~l)M4w3mg9NI7O6|eq>0e;0m7I@_Y&9JVPql2kUbwJPWj8BXfT_ZO z&v-TMVVY{qG;g$rm!J#1NLs4(cEN8h+6rAxc9HK}WT_d+u8bCK8&j4}1|LPcD&F~Q z?q2Q+Kqu8Wz^s}|B2`CSVEAR*HNN}I+M%~zOGrd7%9%Ss%mV=Sn)&ZH#gwusLtvtE z?07|uPsDCo+FuK+mt0H8LV-x&tL7YS!JlDX-aMZcH4|!$Xzq1wQ9duy?Hbez@7+o) zZ*HJCw_u%$$131f8Rg2HcFa=Qk*%>~qIhl1JNeeWTZJvK;&zt^$EXe!*EHh{k8K-q zI7_D7U^W_20mbZc43$I}BloVzw^U4^X=`hFx5C|FZHF7&!qhR0D{uHu1lF-lc0^-F zLiH^?Tdn(qrG+*?4k#IQU4gEB*;^ZDuUWos3epqi5|ujH2XW{L>MNxu6=-`48j>t@ z_idYby^kn|08Et_!IRUabjL8$Dg0uQc-zlH7PKEM5)=s->-487>tf`i*|;@}m)6j{ zV{-QuHXD)V6W1T5aQu&!gy-!VcPVl6YU}qzOJyJx6}VE9!n?h?=Oq`mHMo$8A?31{Ia=FpIU(A{^l#1qS1;-p|5y(Z(aHKnxC4>&jmE^k^<70 z>D)x;-n*d`;mg<2ns zbgvEAy36gj{hB@{^m&8JLeh4ilOPpA$Q>)xgi=}*;;XV9Yg1!cNxrjXHgCR^{8g!Q z2wvQQ9HhtExw7I@bZ|Jk(VKInDdz3&U2zvKIO2EPZzyYLBhopJhrJ6EiqWhU=*?}X zH>pJ`Wu&db3nT?WkpTBJ)&)Ag&A9B((w?)l@SC3>V3eh&RMOo$cY)Zeu{~?k#;I|k z^o@T7d`6#RbcHrh(v|4*0Wc2{JV5EzyssuRQqVf99pZ-VZC3LxxJRDaKv)t`L6E5A zRd~4N{h7fha?wKD#n+Y=j+RoDFyeN&vU!dS_KMFoIdimVrqLyWldrJow(`MnC2CU0 z^(am%mPsv0sLArPq_^=AwMv6-v2>L%rk{jD!5l>OiGx{WYG}We#nGDb!f!(%v2A80 z=3nJQZ_HMoc@b3w^`u*s^kV5=E7kOyYgDUEb=ze-E;iW(QhLD6Wc*Hd8!?P%>Gbau z8~1e(o4bosl@_H(l9;`;9Ymc9#lJ=EON9l_^C= z45;!?def3h(X!r+Yego;-J%=w0a~}ECM11+mB$R7ktJOY@XP6G?LmkDIVwUDGD$oh z{{ZP&%Pg*uF(SNuR@$$WA9>aU7Zyp|JwWaSX&Zf!Ewa9Ps)xZ!d}R`XK$nFVaMCQSok;Y87NDRDD09TNc&fmytj&6rL1+aZz4&14x_n#$|6P=@iea!u<+Q{WrP-U3RJDLZZQyR4EP>bFxv(wKcI0zyFuhv!lYEd=%g|EcAgpfdHSFV$ zAF-?xNaz~z5B~r!Z5TGq+u9~t+!42t#B~|wxxAduwdlP)GdonZR+Zv=mYCd7v?VBU zG0t)iL;b6d7FkaWj9N&cZ>~FK;$#IU{-zX=lav&|5fl5=VT@g6f zM@sjJ?bUWJRN|81bIS^}Oe1GhgYO(yl_wpji|k)}Qq$hGvrWy?nzHi({G=up;e&#C zj0{&KAt=hx*9FN_AiZYJ$*UKdb+3tizlkWiR02;q9fSeizPrZU7wNK%8aid;J|eMt z-$$e`!uc8!L5t)*4{p-u~zHCY4Ot&PFXT#nov#_&kO1=qe=8KSIC`1VCPBZUc zA)6GkzDVY6GLZ3o#)+cbG>c`rg%v3XQltbC5U-@vFA_7FZ$=VrEfg*duB)%LVPSFS zE#x-TH}bLqaqM$7>0!p>4s8Tv%$<8uwr9h4b`7+pzAnlI;YmR#1{IF8-=%xLB2~&= znYP>6V@dGsuB+kgHsyrwN>-FQ+DD|xiS7@-wPimye&jBEQ=DO10(lw4X?BDTKww-&c*`rFizC%9=wM@R0 ziCK-r0mm4g^{z$D8h_D@FOgu|t}@;7SXfIdR^X=hNzoM3mZX<_2DOjQ-FZMDZ1Zdoh$Nqdk(Ql;RuM zmQV@+MoBTx?OUd0_Ds6Pt-7w*VGO*4DG6JmU^(tR{i&%lM99mnu;uETEh^+8A+WKy z4wY%iobtzR$n=ZFmYhpKl_|msK!GvD`_;7CralbpJPmVaq3f+D$V#3{6dW!x6v&YU z1Rh7f?kmXiCzlgW9*a<98nSeaD*Dk&4O%$!t7yMuiG<`Qa&y%2*j7>UGH3qEjTSu} zHk+X77A%cQ?@^18$!)fqY!y7Be<+_qc*)4kbVj)8nKyj9|zDZ4E#n_V{C>MXpZ zs{3~0=VXb*2tTED#x)xyN>50ksd%7kuIqY+q|ki@*47Z)TM&>D32zv{6CGx=o@S*{ zG^3ZkZJV2R{DeF3P7UjE+49z*z(|Py09x*bRO5cain>Oco4u|jx0+X(v>{M7_6hIS zX17`2qj;mZx7F8Ue$9o`OzQT{x9CIZN*2;aL@026^*Q{UoKlN4a-)wLvNg-gFHN!x zErf(OD|D9uKBLNj1N5lHIVH|!iQ1#S({Ec{wWXRAfpEj6_g`d{E#(smY%8FNC-kgk zmy6_)x_YCX{6xG@g>0`s`Jtl{}K9XGrHfF6Z%mH9D&8 znzu?)1V~SqCU80ZYt_qjY{qTT)>?}d-j>;U#_jKtl^7E$f_C>6@|p4R$!8|)mtV7c z!J3;^4J^8)B@Q~+^#lbZ8J@rEL%{8R8l>ABtlw!2sr!%N;nWg@IE5`}Do`7z-|b$l zybxSYm!xRfc#hiZP}7}!Cf`kQNce;@_oyIDf;r?2`_uU)Gc}RE&2Ja#DAcchCeedt z!z~%JYb1{5IRlwJ>z_6^l9DsZ?BTS_-{Kc8ZpErlR=3uYsaHe^IG=n`4;o8nG-T7! zR@uhWbp6f2apeR^X`Vn)#Qy-kDY;2#=~HC-y}(;y-tTpxyJaB=A1eBeI2h~2Ok10# zWht|m*HSb+L^|5rylM0j*iJVijE}Ehy=@#yD~m9@WS$+&CNZJQ~YThtdwrNG(7^T}Eh+*xPAtH6((h6$naH(m^+icgqee@BuxBW35Y^roN{3 zT-N+v-lMH)_AJ{r8U=Rg)RuweI_MlI4xn)(wR%1`B);X*Syv9&IxJF_ZQoCrmA$oF zoJ;`;Kc~{YB-2KT(MjD)RK3^G*t>Z$$`R%?;#xsU4+|ZS6`F)wvrbl8)HRkY()FtJ z_Ppm4DSWb#v?q`knEJ&jzrj_Q_S)ryAxO1WqT{zx>wB`Y2SM0G&2i^aPwL5O8aDp` z4{M`*W6N>dw%sZ%w18V`c+BMVo@+O8ieIKuHlBPhPiE zI2Fm0$5{U8#daHO_7P$k50qSPLAYcJ$mTuog! zShjGbxLQdmOKWWbC$#Mc{hIVFvhuY{8{2}*7dyP1DYsgOXROa`P?(r4+GSx5`L4MV z3xLF*psFOdZW+8$ZIR_%ZiBeS@4xq{eUi&|>1C!J^9ycl1Oz8Lk5TVbfTpcEiv~Qa zWQ%zvY6+9P_dfppsWxpy_RB+;Dni^z0TGe?X(l2oJw!I5(~T9N5=zD+IQ=SH0BTna zEu**+fMF_<2p?KY>?X{&?$+!U(l)07BNeq$BeC`^++Dnn<@uy1aNKeuw|dQ%k)oga zTcoddm=rjJDLr#iS$5f!JhZGSL3~8P{{Vi}3G`?LZ&6B%X(<^hJ3v15NY2?w7woO~ zEz(pJ5^~?KasI}eY^2KiW}c=lR*;V&xctlCL(>lwaFYa_Qh04=8kM^A+Q$Xge6U(B};O0WnD}T zM_ST&>1-P{{4J|$nmN51eYMLC>MR>V<4uJX;~?(h2lX|}QErUW*91h`{!!&GwBH+0I=4BWV|QC~n^R-7UBj%B~wB2|~FGAn}g; zO?<{*74vd2cV&xxM(*i_X<905uW!{4d_xZT>2b0q3V<+v;Mc3-#ic@5WgiguanBH0 z+FCboEiTwfo%rQrVz}CY+w0AGNl$D73 zv3`xxqhC(aMUz^KS3&EC_Y%`#q2;3=K64(`ZN@!}&DOj_a)vG4a@jYmsbCjS@0jUA zaS2Es-D0wyNL8X`DhxHl?EX-|WQBP6GfQSIA` z(;tzy4@t&f+6J{{U*Z&1Be4DvEXiU&71x zwIp@v?aE4-K6+lfNm`Ua1WEqf#dIc$L;nDZ zId)n_!_6f@Dg((+=9z*1w901okQCc0VS8La+&3v3(zKpoJ!?cG8&yTBoGW(S--l(8 zgn*znks(SwLcW|-JnJCEH@!fFyjR82imiawVeccWhW(KKgFf zESoEJO({O4l>TBeW3D-^6pBcjPw{&7LiO8MR*c(W4Jp(qN-F3{7$b~yrF2s_#p6${ zrrlF!;3Ng@B|E$0{c7VoC3aY2V}>B1&Z-svvjGU6n((k`&a1IUA1L7^I1+DLV7W zKgv-GKQURFx6z$$#EXX*T8h+&CU<*9WX(~gg`vg*(i9iSGlPr@n>3;@%HIJ?N&tu> z^N+7cqQZ?EdpmH5NGD`PE>;v+w`ni9rqt_=I!GW0JBRk6Xeg(u+bJarFDdPyCJgb% z6zt8Sk+f5V0$W;|Rucq`y{44~lHTd!^eMHs=9vHmKu&s78O`{MO1Va$(+w%5T`ed1 zQVL*vydRYD?NGqSe&1By<-5Yf2O5AF8A6g^z#K^LPl5xc@bfy&jitS_uP9q47L>aQ z0%ZKe8JeX822Q!6JFDv|dc#d}?WY@39S9o<;E*E+r6&{w7n)KoH1}V1lr`|1Q;0|h z+!G*s3Z)_+6qXczPfO;7f--8=n6)2=W{ThI6)#@)^Y$XVJ5(dK< z03IXUMR!fjAzDU#pNG|QU2wF&hCo`C2@BdXeJWQf;FH_lx?u@V*|bt-QoJj1u2`o^ zu}777Qnwva$WNLEK%emDv{>u=6FAXU&+ww)Da|#tp`A!4&R4}b46Oi9rALhZwY{jV z8O3b$hOD&9KMgr~eP*EQTSBg1wNz~&0fG7&^B!5Y%XU}r<;U^&LpE*})XGDww({f5 zAK?n(de@2N#m!L_eVN*)h}Ui7JLZ6S{Y9mdZ>QU|R;!f9t|KXkCv{hi;Hxe*yM zzl&JDxW2VEuUe+n8^T-DhUFoAfJe*-7_PWW(<7C=nRYGQ`H8l_alKB;=hTg$w7i0L z6%SO7vnINDq`&OxRFF}iF}NKy^;ul7KbWT+3k1)2lk_JQj#w@hOIBz2n_JX$6SLV1tQXxZXhGu)8dXM3{ zF+3EJ z1p!~02GVR1MA+se-2T}*{o4| z`^8#4>!ZtIV&TM0EnD{}h~3l~nVR}2s3k{2Ftw#3$80i}6vDrl+Eye^KGG`*VppNH zW>C7f)o+?@Os~su?P;~E)}7y$PueOc8X@Sns`!51(SvT<8fEt0Qc7NPB!uRAdkV@> zt&mXBG?q1a^V}X{6hb`IzzD~ncHq}0Y}`^vmgyQ7{s2R|leU(OGY(sa(1Nc>g>^jy zMmp9%GHXUj?BaD-yscenNMyF!LKXsNVHos*{>^m8Pa;Nn6r^q0KIN-HXt-|dmcmpJ zcLaSsS;wOJ(WcITaDaX-Co+O zP_xs^eo$ADyd=-f2jvI<03MxdP6@~wwMQwc-Rf`a&O4{tp$K>Y>X4~Qv7O014-hNT z#|T9cRil>%>%qP$YSH^tt%ux8>$USg?*lN9p^!l%_N}J{#OO&;*K5x#cLyM9$*^Ee^;Y4-?B^V^;zn+3U$D@+Sr6`MBqs&9^E3e$C0ZwQZ+8_fm@|E z>t&@e=OMHt%cWdKW_yZ>r6OFJUeCmw=IUAJ^NgvlU;6<`l>T{zo)gq?xR0sIL>NERSRkgFZD_b-) zOil*d>cA8O0w z;JBlbFs-vIQMb2!mtAC~hTRDsLQXx%tlmdvnq=M>(XLtyt%mxlQxhrrbgU;OCRHy- zU18y;bzAK{ojtT&YI=iRzzwz?_Wwfr${p-VztKg&|W6)=e5s@#xXDv9i-j8Tf>y za#XG9Bh@(jn&;0cIoOi+R=w5TX`8lC4ZW+*ZYf50s9+xTaZRF}RGpGr`mLIAdk3N- zA~Tuytn$UBX7pw2dtF220VPS=vN+-eVUA6@V@MCF<`w0ya)C?$Oo26AC>*GVPt}dB z^XS$gQIajhS+`byoJsxqOHJ0O^|Y5?%=5I3%bJqB)9;a&wg+{{T*3 zS=8?J4ROa-r6mec3Elqya3DYfKTbK#cktDiwQkvGL2W^;Lv69Rxp70vb<>7YFro)l z91o>j5~?~BESCDh?#1S3CegCL6kO_87gm=E9|*A7 z7hC{SIRpDwEId^hsaY;E_DY?6F8S>`^=nO|t)=G*0V>`3cE=x4SuYVqsitb(sxlwG z_^WFRD^)zVTUvooSVM_K-~xJ){cF^YHT|n(q|-M}n`fvY2G;Fwtu3c}P9w_+iIn@1 z+*XpzVUV{PNX|iy zKAcxthsh--VJQ8IOex!Ek#gdWOc6A)_e4?S~0k6(N6SOV%=v{Wz?(5X)P&gOP->Wz>4#8M@+_RXGYt$>U~T!!XCS3 z)G6zg$x0EyRDX(VhsRP$!L2h1%8V9o?eyJAHx_mczo<0`E?fY(9dK|DYU+i;E(pT; zA!_Jd<%P@3TYtltAl$goDOwb8gqX=AlNb}4oLFjn!yH;?KjGtVrH7Y$ZZ0iKR`dJN zA_N3_c`7~Y*h}Pz*7S9Hwu;@Chgi4MJiF_g!RCb_Um-jN6Tt%!UTm>S6Z;vt-l*p^ z$5_ADTeH+yOFmmmLX=4gObjS}{{XFexN$~HX4u^pPL79Nn}w*d%RXGbsWY7MAbTDw z(NR!ZH&aa5v+&)uwu;z5EeCD(wxCM4f%&n4>?_Lh9q7v=Pec|1=R|#{!^lZO6xtSn zl&Ucx@Hws+;*HtP)fO(>XIb!V+s)XQZVkG2tqyHaUg!%0s3HMK?KN%~?#a8+!&rP* zhxJwybMWX>(qyaohzSy&IFdN4aEzjD6p_~03y&7I`F*Bu65>*Ya2ITol^voCp7p~i ztQ`(fPiCULQ2zji-)`SVX{VWSmeXcb(c9@Txu48C@mpiV8Lyf4bGcTHZ9eVvC3kOI zH*&DsiAvr``Hn#z`K?!p8U2(^vGj8{x(~r3+V1raE&Ij64ggwc0Cya7B#0i>>|#sD z$3-W75?iNJ)3rtwY%T5DZ7OvuaRp8KaISeKWDoMJ+_~)8M*B7urzYb{H%&f^hr&ab z1T>{&nCG|=#thbxlV*w>c4ul9Y`bnP*|S>OaGy5r;TsIVB?(Unj%0IHIcS}jOG7IS z6#1J_BXY6?pYpFWCBBK$+AOnWxwWB?x02v0K~d`&0=d*zvDn)tRN7cV8A8;hY)aHH zqZ1XVG@2_u9bMD7QjNLDYce{;ZwM!|2O2Z3bX(>wQ*Pq?t4CY&Qj`KzMB{PkUCIe7 zG>WsJ@Sc#}=CaFS)h#aWZM5)|!Q%sxd6QhZ1_Ne+d93<^>&eMYRY6W zVENwaNF<~fJ51mhsEhe={gBldx(>CZX}&bl-g%d8w2SS?dfNTZF-?@8QBi>an1hpw z!WiKm_B*bOuN(N5%f#L)W&JI$FHN>VM(cE`0nGP2&r{a6mMFjIsN>7Yo1PEQ{5I;X zbq#k=xYJc;7T7~54(|u$Q3sB8%?>M%7A#dB%9?kI{{ZFRF3~oFS!u^h$Y8I{w)1xo z7N+qE3CwURvE#=jaxX@{rK4(|E4zC3_VxE!^3>uRKuBpFlG;Q7J^8Gsw@9d@%*Afe z*7}=hB(0RT&BBkR8J7v}2!Y3X-xLztHA;usX$#jidxluETXxN*4!yh(vLML^wD3CC zITUfq+Y^nPC6<|Srt9_&URu1CZSEHA?2@qrh)C-d--bUlbZC-_JC6ohU+Sv~(ybfw zoeEl;xFMaLjH(8Idgy*EB&g_IYS|CseZ9wtH2ZBe3KzG*Cjw}7;R>6qX|%*APf zIJ{@~F_(HUzYBD$J!48$vh@(v^|A8Of+Z?W=n!}(>owP!aGJJFzh`Z8rP?98r88l1 zVem-vmeZ=-r2bT>s7QjLBed6#n-p@tsf%BQd%qCB;`_F(?k(-D7PKKvB)Pf8Bw%`m z4|6n6loE?YDSH*hh|Sf})3tkzw*fmm+i6k(ADEHaK#J4pIQDB7%d-QV` zba{@mtvuzu*iFUG_uL5$p}nbEBjzMvdW-?hc0snbR3k-Z^)|G71zb6(w{Lu&EJ{?T zWEjZdCpenQSetq-sK#H69CZX2cPuM#Ql(OTyH!U6kJ*_xr`g~5cS>VZ(k$-TT2@NI zFDXT8Ntq}h@CIVM-2O|BPAweTi!|(9w6^gfLT(zg)2|UK45*e-Ao|4ME8C&1rIpPZ z@@&@EwPje@xuj|OFUM(?NeqjhhRbOg+*kROqs+km{F94njiUV+O*Fd;bT0PPTcYiI zT}v(@euEoAk`6LQ+pSc*XEkR;ai_CuP4NZ4f&5)ii)Rh9Zu|&&P9cB+NeePnxNuSjB+Ylt^l51$n(+^b?)3#}X=>)= zTG$7gN-h?aZYK&L{h*R&wT?@q(7L_v$gV7X?tp;YWk%LeGrw$<|KiET%XKpe0>=Fwyem$ zYvP@}VF+6V#cZ-g%dx5QM@!&q4L8H9xIYU0`Ysc;9&nU$Ovecz^%?}f>B-oxK*#G{>QAEm5NgPN&r)jb+Xvsb617~RSd_&VQDE)LZwqA$m}~-O&cb2@7@sNnq&Zj2}#Zey(Fj^ zF=`P3t z#p=B%LdT@RUP1d-Y}GSP*~i6r9zd)dkP9I>Cc3`l%-paAt1@3gmhE6TU5|c ziIe$$w621YT{{_B2u8^gdW`k06VVN9mB$d%OH+{8nLEq@P|HLP2Jby+QeAJ2$rA>P z7iN9x8na=?7TUu*3ePam0Ctpn)FzAR~K4hFWdQ5)&z%>_@Q!V zC^eE@Ll$0Zt}yn+DQN^Gl(edPguc?#>XNO|B08Qr zR|3x$DoPsp59FwWTQ$=^*g9<_&k^jHNHPMyu>@H+H9WJNpqY zHnNb?pJ0@)a5Au=@@>q0tI+sb?G%v(qq@)Wt9y1X)P$|iDbn^4g#6tE5gF+<%Rd@3 z6L+I0_@<+It=?N%mxi8=uA7UTG*ytGJ%o46*Jd0y3TCl%YQ~gSQtA zt*0#6b;UMaa&|ZpOc)uH+;*(gWV<4$vc<>7X}0FswjX^T_T4k`j#NiaYT7oC%XaT8 z%1ie*R_kwJ*wUUMXx)IQJm;lrWLZM{P(v#%EunO_fl}XLd(fkZ1MAOfp0>t`oWFAV z*{gf2i>8?J&eXI}N1K5mK+*x*7(d^&&moMMd+_^)|r7hb!k?Aug2p<0cwK|}5 z%|#n$97<9`o=SJA1MAA5LUR8)+AF7MTK1> z%O$}nNeYqrz^X_>N`sc`N0yM4{HsKbzh3pD(3C@P%bH`X`P-pF5VicIp5NlNdy5kD;x8#5Vhglr+Pl{ngH$EI`hePZwW$=JqTqG4QsK-hPTNsCioen8W z2v~rJRfQ=2S?N8fVeEarhT?7#r=GNVP_HQsFUwMMkO4V~=~4$js`zHjT62yvV3F{{Z2uFXO8)Xu|Ohg?)K&<(0Bl z+EYGSUUO@TGk{M3MQXfgwPuPbt1~pai-5!WDqD5y*1lD?z3D*%fMY$Yig27{xSaDe z+|+za`O{@#>!IT$OMxyg>3-s_V=rjoR`$&lae$)4{sNDrrYV7mA%4V zxehJ1h#6pIYaO7TE2GEcj>t&rd~%-+_+P_T;olN@FR87&8gI>Tll}ml7v0(ZeNy^Q8G5Rp(3!GQS60i)z@vbmuxiai%aXBFkKGj*;=C8Q-ZfIbnBF;Ee8Q9Dvwbd#~Bs0F-AHer1~+m`;ATSfmQnM zT6qqHd24Y*ZO>vrIp9|(lGJpGt|y}1+_hxZhRU?R;(B(L(Nn0k;Gs&~0{EFAVAm!Y z{E|^)yGIA8>sPm)DR)^KLpmLks~c=A8d6$HBP65psPb#q;J>OxIN~AEk70N+(>Rnc3Ldh3L;&8w5FY6mmT)n97n)0QNs>!<-jq zJtS7TH3S-3n*=WP?=JBq7aH>Nf;%47$xoJysjiNa<5#@B&|GD0hEjl)DNG%s zVrP7b7%4m+xvuq(MOU%tPxQ#w;xZL5v2EyICFtCNsF_@1?s%VvD!i`u5Hs|#kX z$^!0e?Tbtx8CLU|_aJxcTy43%jW*dggZ2GR_-VRMqE&HW=Arv#zL1C6Bj&&`Qb9No zo|TmRc+1h$ljCgXKNWOK{RKLelUIqm({3+T?aHmto!()9+7@O&128&@?D6rqDxwoE zTj_ST+I5Pp)S+zWmg4Fq2(w9k1{qynfpY2YizQLMo(gT=I2hiY2-AuK1!C< zpEVM2NS=ADCz35_RF6i}ydQAWcDFZcWt&Ywv^{Ndvn4}xE=MVYUpwSZO|Cx3l2mOu zX5WW3ok5*s7m(O3sVGs~bGIl?;5Z=9*owmnQOiftmz`+&g|S5Q1}XDt7CZNB#6Y1 zdh{U%_J*QrG2?4nCLC>VtN4Ywmf~6R_cV~9goT0k-CN^>Z|&JG78WfmZG1mw`nNE( zIp_JPSaWey`jQSo5=Cv!NzqCVrdqIm!Rs@oqQMTj<0Lfu=t2v{BtggKiN{)*V@=s> z9cdPHZwIlc*c*ne!drp6;s=(r6-+EAsOi*KouBITXDIO!G+T`!hnMALzvQ4f8Q{$H z8RM;Txi{IHl4Tun#_Vma-n&AD+LBu(w&gfDl@6js3Rdcf{-sAX!u_KBhhCdjysM=G;Me zu$|4cKMzRDytB5|97${dlWV{H1^^203` z9B?*Ucpc$C;~w29akaCXF3&Dv-A!JHCVaI5lyU+3QjAn#$Um{vKdXgb+AT;)arG%mZ7Bw00Oy14 zSV~-yWz`S3Rm=9vWrotHoL8k&k9xdQEg|PhMg5voE`v)_(%+hpNSMhWboZ{g)RDbt z#n+m9P1a4d#2bdv7D)g#APmn@70(+DYg)#txgqyOmsi{70rw6&7$cY z4d0P}cEa2$N=lLvToM9+$;M535`v=nmGwJKC038H>x+Kj3J$g984DobnK%(O!IE4f zW^XlpOE+E~X`hFEB%w|=lko26?T+GW$d8lqwwmbYo*Mh21Qr!=-KN5XIN?ieZGetB z{pzQZp`$gIpVX7evrF&1Ty^JI3IUZ!+_-=f>^oN^GQVStXb<>7o9kbQNlS0G(3Lh| zD1jv7HM-8$jr|j8{uH{?8!J`XT4^ZS@^=8WN=zN6KXF~I3oJ-_E;XopZl2wnj!U7X zgq_3w+(i9myv)8Q2BalFMqZA^;u!#~Z94k*y!1lCQX(swPCx>eY|^vh{)w!+b5`*3e3KZc+J1 zN&STNu1t|`TN>=B%V~A%o%iC(`Lv}%8{S&(Zq7>EK-M1A6Lixb&q_-C#R8%K0KNNi`i1>gTxo_Uut(Mx3U(@ut8VzeOpzD5ONJv+GclVPNMrZP29SM zQiAJXLh?$YC-klt*)BD+6l!21(M6z^+CXOtkfjOrR#cvZTzS>mvu30|Qle7wLUSJA zR@^BM(Jq_1)yAA{9$W8~I!cDnwDuLGT^X`RRcmjpoym1p?lx2kiisHc2i~^%3yIL_ zEViJ-dSVx3+h5IeEk#NP=D_1TQm%Stj#{DX@gAh^x&?|^G$jjdMS6-|No}VTf|WF>IX(XX(z$1gmq!Cm%l;p}wbU${ zxkF)_Yy~!$^H4@4s}ngfUT%Dk8>C!YXIW{gF{Ws2SUv)nAnmybA!tE7kPcvx9qJ*I z+0ztgxudlGy~^6T^K7lpm%V3nMo*+?pVGY?e`7;aNxipA4miP6%siM$DcY^D0o;0Z z`_~7Z*JhDlre3xd(*?^kwRGD6A+@~RJb>K%s`rsI&2xCZf5Nz!&Q!|}XpJjJdgjUS z#f!;9?;s~}Njbngnc}&B{{V7dFA^M^Mk@6i9XDBZ>r%BY;U5j~%#T1>5xA@Jt8C9o z^s;7`n-tKaHnhx-5qK@X4(VDudK31xHn)!(o421rmReN6Xu*;b$=iZRuTK_6(o*zq zc7}M8$5gq}nzlvqjiT+>Y=o2Ks^9}LJ#siFsI24Ua+H)zpVYN;;K8BW=-Q=;O49A1 zP0sPS?T3=UVMDVl206niNOP`SG=)VvS$I~n}ygix1ZD*YWEEM69H0& zpzTpT$@}KFhmM&XEa9B-Bi45QWs+WI<|L_NNi@zqVi zI0;eC!_<+?(}o#X=+Lx(!!|l&9~WhK{-)7cx_Qf;w(HNOAPNP#5wiobzJ zY}PT|oI}4Es%du(Tv(#o%H!7C*6j#`m`b_<-|JezE{^#0KTp)zw!A|w+BmhKB`dsn zd!T>fk<9znjtLqkqp7yIW8j~;wROf^Q)__ZN^jy2KQSQf01`M8SjrrXB&_3f{b`jI z+r4Vru98-yd8SDtCV3Tui$*+nmo!`CGjqFZD>xe*9+mfz+PJf~(lV25wdW}c@|#Y@ zIAoQNN$Nl+it;6nO_|x;H)7YoFq;<_aN62R+)|p@lmj4{>>$(4jjVjoq?(Bx){~~* zFzvfqh_-PI6t`|#Qo_jMR4@;@u5S)fn|5s#P_deGim|q8(&3LiZS4_ml6qnXQhBX1 zTb(v@ypHIO?7L&9IjKJN(<}?1(^l=kdBR7cM>}~F-nx8mA8vMZCehaD9xS-O)B{g5 zYSXHPC@D!!)I)9qJ2C9&lc%L?Q93=com!INbff|Z{L|FeuS#1wDAX=F zcDGnlC6L(xD?F~HErA8?oBPnkvP)|w7OC8*>_^|4-7OK@E~yXO-8PnNO|vN@d%7ohr+t9;-PHj`85~Y7pQpS#w#Yn$x-Q}R9ktq|5O!hK3sItpCbTe?L60NBTgpvT7 zYp`a4tKk%Px)CjS88wxQvB3+3D08^-`b5b1R(C`7{5uqPl4 zHg2jY(Z2B(isQC^AAOMf<`Z*mZj#te*ivO&E0Hzm{{S&9 z1Z8ZkXqz2iC0Srwm4rKHa)sy875nj8EQ)H*rO^^J%MB5WoikX}Th$HYAuQe`iDhIN zR@A_7ffzLt#R(#19a(3?me$@E{#N^&hk{B{%F=wsl92&rM}Vm(A4e~kjbhhGw^NBu*RA(?soW$2dh#N>B{dbZPeNzMz8_;!aYpONZHCMx2AGzQf*hXDT_waxj|gO&#S*`bIzWP zB&d}-t?!9`9_3no`(l-ClmoEvN~0Zen#L1Re2GyS(@(VB>Mi!AAT1;Z2bSJ4Kr_(J zYmYaZ@z07A(MsOmP_=AITYF3hC6*i;oDd)=ul!kz^sd>>BPmvazdaG4l zUZsZ;z+p&fMG%sro*!;pr`va*{oP6{^t;anjSI zT|H*Qg=Lh0>J!-fs`mTRld+=3%9m$kS$VJLw6awC*9BO@LPsB3%_yE=l+Fu=>Gtv+_Hr< zT7;-`yY6dCNX(Y^#1^eip1bt5ceHI~DoR4q2NBkeK}D@H@8Q%MZN{BuK}k&RPqbEd zvdvXozNdmbgr$)x^APYMLQW4^_NwSCnQ2SS1vi2vB`V4K&;>S-rewI386rj?ky)~k zhNp1DCR<8m%1A`P?TU~sruX8CohU|s?hYf~qzJBFTk1laLGs2*0-zs%b5xKPEbbmc z3l6xCF~3xil9R_hX#u3dLKMGR(g*@dvjVLR=$XWzfR_}aQb6?y0Q*(ZJc^fIOB!i$ zrxr?bgaQPQuk@&4Wf!z{TY-~(t&r!`W7EgANEr7zv$|uK0^)9M0VOvL6%aZ> zF_Z07-l&F)`hKRx<-1D_8^x>ulr*fM_mi2$IR5~kzPmHLPpGd#Cg$x(E+J94H@)SF z%=I8+no?uCIrO{n*J^zayp+6>hMTu!`FlATP{H@8PQtWmIeO^2c^?eg+X(WVO9@hO z86|vk)2vm}C8Gs5cH-jIh25wuC(C#|fw>?Y03u)xrlqqk$gUTPP5b;gx(rXVu- zQf+RYXs{ASQl!FUlhDm%@$yn=?0H{hy5yw5Nv*e|tb&|_Xc!64;qTj~dxb>)MEw<`1e8GdyB0F}jJd2qUod?D` z;CAxL<%?D}S}>C1yGSJ*L2hyhJdV{Ev15z1*^8N3?-N^TX+w7Ea_Zjw33YaBB@Lh` ze~Xl#tz7c){{W*q<)e~j*~e~fnRdx{&7mPSp-3tTTDSnjPu{$#`IPR>V%$j`_|)kZ zT5b5Zw7g;OHEoceF=bc@8UFx570*1MGqtiOD>WL`bqzW7+OW;ep71csd-s)R)U*C6 zj0)()xP65QZ0MI`@m5}a&Y<(RjfuErqEZkK1w*}iIH%0)j?9O(T@6f+UnL8*T^KPgo}3^A{VtHM&ddUIj^1a9F(+kNtxFgo!^gN zy(+kQ7HlLX#Wv5Flq0#0550FrJY!(0tisYfC>y`GSI4;X0j2pjAv?A@pOr3q5f#+@ zh^%zQ%+K*wv3q3dpG(SP;M$)hv>z?StCJ#Nn&I*I=9u}Iw*Di#y$!tUZnWYIG~!80 z{-pC=ZwidTPR&H>>2~dR8pCNpT0w@@AoSd4+*W=<`985Ule9@|;-%}_fU>q>7c28Z zn_PTzMEyIS|#|M9O{Z1m#=o%ayaV z{{WY?rL?>2B0?W;Exxc7w1Syze}r`vmPtx6v^P|8n#*W9v+UZfyMV)pY$4~U=syf%wra^l{3R`+hB%wa0| zB$zx7lQGS997bGasae`@M2c6T<$7;CeSl1#{>Cu?yhM4kOuyXCOZ*q}(%Sdn56d(|z*mG5b z%K0T`>R!%m%@WM&uQzVXk2LCwDOIPf&|*X)I3{bp`E1pFjr$!bOgzV#V7F3J1=m5| zl@93;Q^Bgb(E2p>9cNOpD{-Bxb(C#oDqMsl40^f`YUZ9UW*Ihd8pnxmbk}cf-~Rya zea^z7t;frA*q?D+^TKebQM0IO_boIn7S_vk6g;+EJH2E9B03x&sjhw;SxH&iS!vDN zS~Rz%ha<>!v4RwGGhC`wkR-U757=H==ywWk$+qp1;a1f)cRE$bO!pa)UZ=>ajo(OR z{hh-f1nt_C+7@9J%O4_o5!#cITQTIK%^gnNH#dQY!%Q|BC}GG-;6`)6pL*!$Q7t}2 zRA@GA+F2WC-WTatl$Vqfu%>cM`q`qfG{j*F$EJ@a*GZt{pm(gTW1 zVo4owS>uz8=!VQ4XT%BB?NS`GX-_nE+o1_59-sh825>U3y>{e$**vdDI^)kZskLQl zf0EiflCpn1N|p2mwuTioYzoKY6|A_xS{SzqNLtsJ0EmJ*n(B@P6fb7&@nLPQ+S>fO z<4W4=U#m`2(8h|G?Hs%-4Opyk|WfDb(9_NDczOB`}hRG1&85OCKWQv~vdS)M^QNlC?SJl_zdbY91EIOJ_l+ zYs>Je4bw|gm$xV^6?tJn1xM6m&jYP>V8;}=vfHCWPt+UIZf?VEsc$>AMdv5d0O2Eu zjuaQm2#rutY2XK4agouOAjns&qEYOWi5^Js`DhZ?*f2 zq&SO(v+5~GFrD-A^^Udli|+-<&U#jebxmgFheF#zkWfHaP5~Sd2c=??UsEWnT#KI> zr41F(fQ#3ea#HwQCA6QNAwOJ_dsk*mONyhbpVp3e>CfF?8)nwn4imNQ(w)EJp4G^( zbCnYp8v7lM=Y_1a8$)p0$x&^v6!KIu59dhcI%kUBo+hHbkkmaHw)!htbMM|Ws4C*& z#BO9IKA;Lrr#(+Ku1vfa6DF_&93F8Timy9-O8HUV00={dIOVP z@k%R3KOGrsv2j-G)R3f>E(k*t1r8s}j${0*i!HV`sT8#a)8X{_kG>zjDB87h4E)Fa zdR3_FW-GIQPI(p#y?B=jo?BqJw-ghxL;xUu@lg9VMT=W&EoV=Weqe+vwKIZT(C?eB?E;2-;yI<}ug2V!bS0 zOfy3Lorx;567U!FTZ<1kU#zH>?$m#r%1(aioL62t?8Z_tJUik0i>r&Pp>)u4+!u|# z%Zf^0Y!C}z_squx2&I)NY|6PCwpOC|Qem>wesNSSE+!h-GtYYEgxnn(D4T~t&~N-u z_LFMqxp6FoDRzfq0@NllVC{}aHPtAaM@YiG@T*!5pxvj%o8&37w(mT+Upd;I0X3YS zv|47hf)uM~P`E(=e=$x8j`-l$9MfRcoW1+V)Ad`6hOUa(042n%6ETuO>LR+hB^wkT z%Qwqr^G&mA%H4Mt4k(Zm4&n)bpWpVbE>h*ANi>dwSn$umcwkyQ^EPj9-up{he8j;R z+C8h0Vx04-nesU8R?_`!7VVN0S|ve4orCjFYWAm+E>y|oZi#KKzlauZ9Q3b&w2+<$ z^@CVsag>rpX>8SP#^1d!TsT#0ZD^&fBNDaY36HnU?NsH(QJnJHqc-=%&9iERSv%$4 zU8BfO)3FFgdH1drERvTM(aXxTXuqJ|H2tHaQrNWHg}CAzk`c^p8JPq2n)IWJQC4(8 zuEhPD_f}R3V^X<7&<^tYw;;)wgW66jNXL^Cn{3TCT7!2^wPxn`R1wfsGsaN|(b!#t#>M#azN<2B`E#_`I< zJe*FC!q&GJi@0^>lB=6n)TR)eBsxs1Z+u5Jy7OKr@ef{m3Z76j|&29TgB|wPs*SPW&1jiz{ z--|CBzRp(fMpm1zJnx9coKe2X1O=oga+8d09drFFIQU9me`b+Lqj=8kQ8yOIS&~x9 zRRd~gDX$T?;lscdE zt`95zMi_42dNX@;#(pDsAO2jmzZQ&I+1j?Ik#6&3smsMFGD?O3APFRUS3isAm*A^woBfv84LY5fb)`zCGL(qqL>c$4?3omxYT==` zJ{e#+V{*Hsp{GJqa`S?GvSuMZ&^_y$8d7PT{Cg~Do)gqOPp9e{gAe)kmUjg%l_&$8 z?-T7Daad%6=4B{Zw)NJc_lA|ATVJ#SKuL08E+cVLAoCeAE0Zor#yk-+R9@2j9MzL0 z(QkCERs&AmDP;|WsAFqqlO0S~G~pElkkip_%IVz;TT_pvX4NDmhf=MfYDo3>$Ru%! z^L(66tsLB(U76bVh?>;(ciefWE-nzJ;?=M~c`A@VRv-b_xvf9rVB>7+Z<0iQ3DE7? zLX~f4Wp8S=EyCg-Q;sJ;ERmSvE9$XDvuJ4^g|GOnJ|5Gp9bK*4$SQ&4HcF2i#d>jE zQL2+VZwh#w_Z;}AH2ad!fEdDeDCSgpM{2G{=~}aM#5(uJ+xb=vT3EV~=Be2!S&mch zG*~#QGqn4ZKWwo3Dt+Y%NpW%_nJ9(SsUCQFNJe3_fwT~P{irOFwFDtVvPn5${#Vt|;b>(p%b9xPX~ZS0a)ViY2vi3qnkX5KkkTqIjdH(`}hH&_ef-=}L@F zc@;ETG*XW)-74Oc6oN8&rr4iFs~ub77N(cEWjqopIW!2g>Q)@wm%@^uL6Ua^+NnE0 z%**`|tx0aMe@0Q3C_|(`1IrOizcb996fR@=TBxqM?q7nu-L=Z9MCiWl9Al zC~{@$#QMV2qbL=43Pk1 zF`CM9W)fC;3;zIz_eR-Bwzsxrrj)e>Cg2635OM?^yx>mf#+~M&r0HUQEOU~LBJPb(3hO#np{o2H-MTlSN!ajYuVSRg z?IW-F>d-=g&+P1umA;8WF%lxv*Sw-Ior%RXvK zplzHHh@WcbkBiOQBa=6D)BI&9(=F~ruAt*GlW^FE)-eS29V@ScisFcI_GezVV`Hhg z@E7ZH;@5Ik^|HZAlmQA;WaMNKIqOsLx1v_v89pEI%JrMq6=!f#=a`@8xC#*25xYJX0Xs64I+jD~BOFNdIm;(_%Ls`*fjSpJ4xI$cgPk$*t54X}} zr>UN!-!#`_q-$TDFr-}DUVJUni7WG6^rb`&C!~LRxf10@J35k6W}~Luo0O6Yge!MB z=k%J*HcOqFmKq!SrGw9-P}8*iSuQC|Tiqz34z^Pm8{(UONAQ;wnCt7xnQd0hej02jFC zm9s>^%HOtL(7o9ylftUeE$q~{^B>q78A%?Yf=|+}kUfuK_TO~4q=mRn(uD#i-h0tV zR7|%azf#i)l_P42k=yH11&ehX^ajS{1txjvKn`-$Td*5-ptKS445a&ePzGws+CaA` zTXv*NeprR1dk(cslAfbz>YX8rg8IS=V&Sk1#Dn&%hK!9jTXN%2aTl#EE_r^X6mXG= zKGQX5c4*yMS-OP>Jm*jc{{REaVI*<4zgeIPZ>@T8NV9AOw1S}W69r1?Gyx8Z`cR>G~}qdm07G5 zxb?wOf>wczhz3ACDNFj9vWoOepW*7a3^EPTNFINrxMKk-?t4vnuPcKml@t|eap1eB zw9A`kY#zF3AQd1fXe4e6NfXXT+Pv(k%65)S+h+}Xt|q|^o0l4FiA$*1VdEr9fx%P* zk(#xaBppPk?NJ7&;!O(UPfAopqirQCZM$>@txhZwlM*E+AfBCTRI+5)vLlPV@o-j| z{M|XL_491wS49pmN%=?^Sneyo1}E&zCdfQDsa{-b7dIMqklogzTimNMwaQZ<6-Qwp z`&QX}b&@VD(POQi+i&=l=GFUSWqEW07SdBY6oZhDaC-aK$HT^-%JKRgw0!$_ zadE47f$c)^PPp16qimsGz#f(K7<@m25`sk4?CZ3x9{&JO(%ydaRk#jZZ6Ktmy3puk z@=s`{;*%*Yn_4D;YpNmCUff+K`D;p2(sqw9972`Q@sE1dJ|($vHtf7VXQtiVX}4}N z+b!-|L#&apK!8$KK2sg!Q7r8$63Km+Q{mUGbbIi{)v6l0*ljkx7D$uNUMHT_f{#6r z)sXm?#h1wN!gS_ca?3_#zzfVREv@%bHmOcxVlp}r&SJWub41aKu+Y*j-?l@IwPx#2 z+?6}I4kbrw7Ds81rEzD%*FteK)vq%B)2%8JyRJb@=h$@}Vzcq%EN<9BI}2Oew!3xp zvv9KwB}>R~91)LTJ4JSLl$o+r3w=Vxrc~|St-AN5p{G<7uPi7)B|n-v6N=v)Hf`BW z9u;@Pd)g!U&Inv6E7O7m4&yxau74vPqbWwt!$V$)X{U#E8@F_;mQuGH7QnRO5dibX zex2)v3cjXF;>z~EId@il`!}s_5Vg7xlKWvP2p*uIt`oX5-nVdI?o73%>elx<^J=)d zEjrr8)2%kyK4P*U5yXhaXS5tmi;Md!Vi0cs0E<~I*}S$wJg1m$WT2DBV6G;mMYm>= zjclxSBr>$yTHCv5$bSivg?HG5u`YfB&Ax$pU;bpa{(g|$` zf;%cn{i~)XaE&7qPSdQ;nEj)77mK}0l1i=&0)k*EJ;*&Oq>8!dmS1f~?6#xkqEomigFUcoi^auLwsXx7e&fY0}UZ9IRvknFnUjJ zwdV41MXatSpz#I5-c#XW`#5%2Y^rI%+M zZb^gRwB%POljJ01rS_v^Rbl4caZ?tq zIF~oU0|X{a^shEPLYtvi-r23J>bhQ?Y^^fJ?N=88l>925NmQtqP*Lf(kyj{WlhD+; zIys9?4)0jgE^lrwP^H`XaNCM2TZEYV0|yn;iAw55Q->XsS!!$2jn#{dw$h1G3Z40Q zf)WpImFe@S(lm^%3sLg}Ht2Oq*pulH0#0WU+;dpXr&cCaaV%fop|+W6_8cIkZK%nf zhH)dkWs;+_HfU+qwpw$JxW%oi-C;pP;+#84{{Z1f%m=+~2Wrm9)C8BQ4En)k+2VS;Ai&w&{VN(A9I2@m8qvBRq z#+w;qX7lX39V4>!|%z8Km1SuU7JzOHVbi>67LURP+)n zOFGt;%GzR6sJ(Q{EjXpA1S??)LH5tRVBz+&IWnz-Ukbzed#gwNKJB3c^PaQ&R?c_m zh_A7mdEt;44h1)FaNrV`2mx7u0Uwx}^s%~)o6(f!gx$T%>$pqJm8i199mA3g7z5_d z72k{OwoBH{s~-w{8?Q3^iVYpEr4JwyvN=#%cpk?!$K=AI-IW(*#&k<7o14!$px`SD zN&tWX=p)}X=X0pj2QAS_yLBT_a@r+H!eA0d`B#}aQ?^WeCHS1zYt&>#FyH~l=bqf^TX|}IhB}*t$5@D?70LhcywOC`zk_k;U z(V1%d`d~-IU$**`Kuc>frrU@E+(l)c37A1{*)lc8wOhk%m%&x33PEf_ln3QL(Oekt zta9Yaa@`$py44@mEYW&HcK0O?Bg^5&(vm_!_k&#-BP_qyLtkCJoQ9=%&+&~#yRAOu zg}AA1+@sW~Cuq+CAkS*%_@tFtJh?k2b4a&$M{T<#+q-o0#jBuPgfxObE{VmOg^Gsg}0r*t*pc@f#dkRJ8d^k4h4Q$d06%X>q&Q?wOseDd%k)_;3?$ z+_xxPul!O|+XAqTG?h_KHmp`YA$rGAX=z^Vs7NZ{gOkNam4Z29k|k?Ht+fZW2Ag{G zU@B6Q(vSq1nN<7Da$?27)LE)>FWTv$*=3g6SaCa2a14Q**QXqgDuvskhNGk1{2R$( z@)Vqor9v`*I}=CRQZ$Syc1@x*UbhyDZ^~L*^OE8+t_JPX?s``44H_iLyd$lzMbvec z*(iKFhhJ%}-jVYuIOQW1Tcdg+z1NX zbvE4{7l*$P^xp@%v_IjyZAs=-rcKVM3xETUN&$@f*1Re5do7v%DZ54cZ$E9PHp4ey zk!r(RQUK*B%!8gO+-CVD(5csEXNYbsbZr&HTZf#zN~E?vR1J_6uJPKsINGz7r)EEe zG{56EjaysWCghcZsf4(+D8}hL?T(xZ!e3paYwC|dX8zYr)3sA`Xa%;PwT3*R7Uj$8 zR#bYB5+v7N430_IqMCi2hl~7H#-gh`vWG*6fTk3rji8=(jz0C%i;SOVOk-@br(R!c zNJG}PenpAeQlu!UYgrM#dhi5s*0!EVe^$LO`&K?g;N|sYx=8GF9|*6) zH#ZKuaBi*dp)Kr3r3nWLQ61~U@^i;0(IbX&wstSP-kj5pI$Hq@ml5TvLKHtagP+>G zq|;v$M!3}wc)HyewkW%OlXq_QxP8LYp=D^Ft`rF1@m(0O{{S9K^i{ z7Zj(PkW#Nq9upuAiLXZ@a#byy^4~_i#-DbbWG2GxyM177amQ_d^AfTI2{;oY6hS!l z3qekmd1Hl{ zuP;_hmI2pYYS<~JpGf(DFbwvL;<)qS;T}lJ5pQ;M7uPIWY3Wnfjy9WXgeK+P#mDxM zhZ4}te%0uI$765ob*LFO`nybN?z?8{-de6gO72@zWno16pzsbm*Snh&%c?a-7l`bd zb;pq7%sY0<)w0>?DN@N99Xj*vUYCuDLNroaGkgK9>SF2pRa+@1%=lK);y`GSV30bW z>}I_0J`Jy{GR<|PuJIRzbq^8hHkym}&9`lA6)Oqer6^)Phk$xlpW@{B6LXc04@YIA z>0?FFpRr0BV&z+W$C3oNm@qNP0~}Y(dAVno$mF^vZ9a^2rLPkBZqC5kTib?#d8@mz zxV4gykVbbZcmSWJdLQxelst}pnQ)!yqs_Fx3N^3lXaLPXGQUG_IQo3(`3A%uJxV_; zb^F)eP4SJ{(ZP0i_kIF%!dI#nnzg!Z64vxPYOgU6AdoweJPx(<{!DS?Pn*%rG`mG- z^%dy4or|O{qr|4I;)u_CmHT5s^0;OTG*){A!F@mZ! zQb@u&YFpEuze8;KLBOvqSvz=*y(2w(RylI(iWA95=k;sb3yUj-DU~VIr72}0(*aQi zM_!c}GD;^uHeIws_ck{l4&weE18egC03(G$6r_Qaj@Tab^JQuBA0pnpql*m^)oZ*( z)x)V}`bzNj?wy0*=+lLvo7Vi1Lz3Jz9&OW^> zq2sw)GpZe_Cr{K4n2SA5;SaFao~GSi_K*U(Pgw_%#8*yCYEh~kCSq9Xsee#%=Jx%o zMWMlN5L5_XSW*w=j-rehBa3&~x;cgwB9TC{6&Q6J+;0Hg0--XxMc zBNMf@e|stPttwecR2!6y-9Vb?do)Vj8cp1kHLx&CViFV;AQ{Obd8ZiCE$D{v`$#{{ zRG*b7>V5wJ%8<5Rw?QngdhOC1!a*>pGiCk6`*XbnP(>EU$8uR4~vIe)LX(7H-{b2{=Lk z^Z-mKn4T(Q(3x3xBGs2)^2*YYFicNqsu2GG;+CS^Jga9yM&Y1P}lTD)S+dD{8rJ%?tC!y|D%+`Et zlbh8vOA_O)Cg%M`Ep1U@vE``8=Ib8RJYs1xhVccpo6p;PRl~MV$OzaJl8hgl{6pTS z;b zRvb?WNe2=?V@EWRmF&&Cxp{YNG~VPTqN0}8xjUDc{{ZQP&1D(WH|DCShgQ+pwPxwG zvZo$>&CUmuqMhfHwDl)3M{i-G_a(#ZnBbw#K9BRNf@q$1znlE zyjgom@mek3QL`RfDl!~soy2hjn#N5n4bPGtscWdZvRd|B0H8@yUI)#fw#;i2wFO=if z3-VZGwvt*3GPc{Fm}BftDO{gOzACK9)t7O7ZnQ8?n%iMxdxlGrCkp3`af4kkj;=;k zY@*JY@J%-Bh#{houZVG?Loy}`aVP2A)|^w)34Kd?F0+2^suqR0YJ@g-TQHw3NP zN^S{#3sS;P@c~41m^==1RGND!tJ&A+np+PBTSmv3KvEXp%0wKWin~Tq?2$~NE;_HBO3v{UCW=%FbjtTF zFLIENR3{Of_oR^DWDH%KS4dlm3*uIIG?}7im6MJ(wJfP3VC@NzZxg|%HNA{=LXg0TNZHFIv)5vA8C1Q8P^-oGoXbD18;#7vU6*xBql$an#%07`& z2R*4MU8%;x{b~h4M3SMCIN*%ZY-)_%Hq!pu(&)Lq?S}TLB`F{*PwJScNuj!9ekJP? zhE|ZKLYF8n5x5?Mpzl^DTe$OXCEYZ)dIEPr`BIU9Obnh!YGgD~*7R3(jX&bkc=Ey< zSCqn>2|`SW+>_U|S2Xdd8A>0F#lG;rimh!>7}spsE;qTfUn~?9L|~avBaztjtfPaA zwnN0(ldD)8_AE5(r*!`SF4@017g}-)iE-G2Dd%w{$r!Cx7;>?EQYl?{8r7?p^)Y^3 zwNBR^vs+RYPzc(g5=YQQCoU4CX~XoTb)o6^7b(7a+6${8#Ifbz=SApT-N>m54@t^PcJ*)5SMm%J1F0ZQ~z`)kD_zs+B7~g(v_AQ3E^!?^Ln#c5*b+(H5U{ zy>7vP5aqqkmF9;Jp|l;`?d)f|bf}q5IXYIXfQ{GV8*cQU;c-KjJO#8+a{m zC~gWz5H|1u%#k$`#~0AjqQAkDx>JKVe$S99lG^*t|XXA9<}PYCa~` zu9(%XWI1hY5>k=asxn9ES*#p_^+t`);RVKkr(V-F(QXy#QF);&L}V#_&J6V6R8I#V zV^O2duQVH*chHuTZowA?gtZA;7GvfjXKC-=xNn1^UPThU{rg&DjV}2MN|{nwQMeM@ zhI$^LRXJPHpZ6?{Leo=4%MC3_X=sO%us&dMx45koQ#4U6S>0{3Q!Te`=9Q(^lt$IU zM+QH=WeCxRNmB=h{1)~0qhY9OuCy9!a-C-FP!+hHu^eZEPH<92kkYfOzDAF9<=MVM zt!(UCNhx8X>Xu_EOk|!b40tKpVA?pAwU-8}b&Fe+B~Onn45=AHbKBbxI-2Oo1eazX z*_0pG)2!+YDObB~+XS-8k@?3VN1lV4<4|4DoHlgYD`>hxZJ2%^ylp_EY@|4HSC8#p zc3e`EHc_-itJ-Upsj&E6QpWz=Ax)OPAU3VZJSja-W6gH>xH!k6qXxa2w>mYo+8a)| z%9^^mXoe2Wi)~{YRsoERgI&M=H*K3yjp4r!xbC-grQNz%wRzMB0ui+;k=0!c0})X_ zCMg7@;;iYfG~GW>)^AdkF5=71+R+Ln#Uwzz1uJ z)2`|6scYPk9^xg-qLdulsZF^j8UzcQY9c$@vN!2l9qhi^HtO+S~FI!yz z5WIyAka+jZgW8Ej-KJFEEf9F8SkOP^o7;=69Xi$8LRh!n@{)$qN%conC#7C3x@K{X z%zqE+h`+EXxM>#YEhP!GSW$5YZWc-AdsjD;89~}Knrmjedc$pL>^1Q1Gqp)V!)U?) zIak!paZ4noj&$s^uRhJSlPn-1%lm~&7Qaw+2OT(4f7q{Y7B;clHd@)wzo$KAad5QF zz+pRF+Hl&VzbEfp`ctdfs&=fmpj)!N5! zs4-~TEZ(zQI~&+gNON%~k=%VVP`NUavKO@{ZQRqYEf%K`Q~btUJCvgkK_})Ndy3a- zre`H3(LINW?^S$ltQ+#s==q~)o_Oj9y>C_a1#%>|y>X_Tl{ADll7QM33Q##Reau(H z@k^tUH|)^5@e{TTGUEysidqUcvS5MUdgl>ccqdKS(wanfw+Otuws~k(vmulr4K@i= ziULU__wQ4Ze}&6vbB$fx-Ui!38w(qX$-+~NRD7Buv?S?Y1+A5#;d;_jykS8ojN~7B zOCqvXnW25c2bB!6n#ojR0%VJ z21nMtELm^s1T&idt?a%y>fXOThW{DiZ>St__FHC(6hT@8Zea* zJyqjMPUzE(Y~|Y3Jl%c!hRWMYh#6NniLEk2{{R{=mCja&CD-p3`)Ddc;F4AH?(M~N zVa3WKdLy%O#@yJIm7q*1BQx5jP-qjgrDsjLO^`|y1Iht@Qd135#t*%idg-#j(170wuD){v=uk&3+H$|W19L1=X?@mN%|mN-Nm9d zA;knJg}8+Q3XUh~SWhBlDAvs#3diC=Qx@*OcvH1cEk|k+GD!D5{i~hH3AAdq(_-^N_hjR z`~KCGe#n;(vC!H+z_wvZwhlvvSrP%xPB^HPc)L0kBs$^HRus!Y5WTy27(cHSgz_ZF zdu8U4=H9mGeYCqf)`Y4E>HRBAc^ld^;?pc8QDdsyJo#xZypS#%Ozwar!bE}yjAFeQ zN^1)&Ol-1?Rmb>a<#C zQn0#hx2}YILdu=8LrR5bDf0&qKYZ6#IV7owa=r%aUo)rMKD1sGv>I6-%SbpXQJ5a} zrZ*JMj84wSLDaNu8_T`4wR!efK2ieR5tA8#0thGRTzTR1WL#fIb*dk1&Y7p&xQp9% zo3^t;l%Tgz65&^_a0Hn>YrcFWl%wdzO2cE~7B#z89|~2)vu+DugefV4MkJhp1}nwO zjYfNBblIzX)s?-~g@vG1yG@|mG{W91Qjrt$brKIX=4WX;MDQzKBHGap+q{(DIPy_! zh5|Py)OkIG4!x_39IqhyGJHj*IiYxIR_u}FGiXwhfroPh<1#z-ucYzRGPdQ|nr!gx zVVkx233RD8?H~pDW(v|zC*Hk92vx_jc>bP`;5{vm5Uqi1<=P%ZxZ0G6ZPtK@2bm_k zKPrC}gM)n@hpFi3u~ogtk}sYC)h%s2Q{@e!6uJ4JfB>4q1mTe;`zkPG3BIzjY3qg* zw{Bf;d1Z&T5=6iQsT}te=s8b~E{c>kUeRwF)pX}ASa#uydxp}m>yB<#^1YI861y{r#(=F_OC~E}6Zgc&_V0@TQ`s^s5_|?snUO zsDeC|kvo#EK^4uFDRw#2J(kB@)Nec_)uXqzx24dRUb(Sr0y#h#;=Vh}O9Oj3qm7yx zE~#gxvi_f`-P!2&)}anLd3ecN?t&yGrooa)9SGv1#*RFfCMS*Ar>w8tbZ(y`3VU?vQGxZrGxv28| zr;D>klGPPgsJEr)hf%-sLoI|N;@`|W)>Jl<2p>Z==VOoZ-ugM(ZQ10Sw~jA7OQkxS zi<7q9)Tx_-prq}{l_WtXA`En|V;B57E|3y|KMvwi!*T6rV8x)`)GeL~l}v^+EgBf#hYWaYg)X?5%#$ zZJkc$-u;9WAdnY?xTDBQd71lGP{!uYX+55Kb*$XKt*X&>rTex(lE4B1g0*{?>t4P; zAA&UFNRv(RquNc*-9F{g%aX#D-=#_f@TnQDOx`<@i*#*jo+Gf;n`+-napJbxmE1m} zkW8J(LQgQRPg>%Kit(|+4Xb0Xt+l6ZZaxsXa_^P{>hpq1kr4p$dslua>`m^A{ua_4 zahDM7wx43_$qEm$l|1dbQkWqCN2){_=&J3MS00YV4Oye1SvI{k@y5~-t2pRw7id5- z4}^uA<9AARURpM^nex<^0g!&RS5AbTqSfAtw4tR1;YTV0 z2%)cF%O!w|WVDs29RC0{LnPFKE8FR-X5tp}jw&R|03WwB8d0v@>kav6TF08-jaZCPcaq2NX=e;yTMN3jQsd-Wmk_;*% z{OW~6RF>RA9Cf7a;3-OjBw~HdLQM_D(VXs*R?~&01?=Wkk}FcxqpD)~vu+z~B@i>^HZzJ7pnVgt7V?AMUc!l1Mgf$(+{i3ebPfnaWWSIao#%A-2p*bt*x`(T%o5MCRLre z_dV#MsOR;4RlQ45yR==mobdIw;RXngn;kk(n5gGddIbG7`rPXwPsI@uZYziO^I&a(Z^DdqI)$=T1(D?VBpNPWH=T*2&7UbJITYURHmT90b*v zXHwLypKn*Qw;u${3sct3k^I9TB`|yQJu9A`XlQm&W5thZ`u(-#_MWTDCYw@i{w7;k zZCwly2@}X(#MubTMl=lsMMT$ z#dnvEI^kt)x8yR#vq2z2L6Q#zN0V9P@;T`g^l}$2YggB(457!;lqo1}pI4*+RABKD zU05@J>cJ}{XU7_?u9j@yQXOHEHX&(BLez02j!2Lx<;_|*RFPGmA60w8_smR?U7lX@@Psl7m{UV7e{SZN>vl|TTR!FhIJCRMver~EmVP_+3eQkLSU z)UZsE_Ts%Pc{#unDyu@(9=)}<7I)U6ovx%P5~DNf5zvmsY@bMX=>%W_8Q!wYtT!7OO=GZO}nd59I)n>ibfLWs#1|<}CFa zE$wO=i<0AzQiQ^GiNGXbU1qvM$Sp>(r>!fw1x5+r~pXFpm3tdGxMm=q9&iS-2F7_B`KTO8%-4w8iIE6E8Q zdr~aVxdCfgbu&MDmNYWn{IaDql@0hKtWWw@Oxw}0)9$dx#3odNaN&qO@md)bE_Ic- z`3$SlPpEZ){V6a4ZcXA^+V7XQIULl57i~assc}i)FrbkHb|?KR!i%=5a@e0OML?O_ zqaj1ymo6bioA=S?p-wr42ubKYsq#!HaBWDpOKvI zifBB_if?UH*hqQ6P_(P4Bi@|~#yfXx)|%d#c2?E096ONM8_5H?9DiD>3o-2_ol$Ai zQ1e!+ZAnA!s20FHB*b?$l+&Z3$K@@93# z`xkd1>#*~ekEEpq*3uhoClHa`XPU{%`ZfERY1i&p(@ln#q`Ld95QfVv%93a1By{Up zB<%&Y{fv!5(^ONTcPyt!S_xQNi`u8kgeafz4{vJLQK?%qYRz3D_fcKTZaiFi+3l?P zYV?Oe`GD#S?a1mVa!8h$r>rXZtBd8`hEt`s*3h=rl{(9VfTy9=i>gg8)cIn|jbj~r4YFuJ#+9ZEOxV>c`^9#=x6x(ZL>;Qm4l0c2#oO{+%Nj(^} zj)~ik`F~F(%VT|Dm8BsB01hyFg!_BeQ%&?_(;ac*#w~8$YSz&SV3egzp<7Up4(zL@ zP67H;Nutv)FG^wEHOH+Qys>p_F0X2rvDJ1WVInvb{#fJew#@4V-pi;{PO9B$1p$}9{{L#VtRuc2^M4K6UrZmTPvh&H*9Z_l9M;nmw+c6)MS32@Jy$TM zvh2q*1b)J|gGNiUBUAA;?xfR(_f}QgiaQ09DI?4TbHK>@;<)^rl$pPw_MRSAlpA#x z?%FoAfAB>WlR3d8%-7HPGHMD);>ekS;=Aj;ZMA4?X_oEO>HgK$ONJgy zylRQOPvOl!OVh1dXU=WQc0$&qB$&ro=AVg|<&_;M%+fCdx;CqFwp?A)ZJ=9R+MulN z-vFp{1b(t>wW>LuK1QaWrN4ioi_6Qkm28xexf>9pJ9ZwjG1{fFxU^UB{{V_wV)IyK z#ujcIA(j*AQc@!-lb_PIT2@1gGyFq%!#Y*hn6#z)NLrt6QhcSDf;x~uGuYQcgkIQj zqYFmxuDPkawyf@3X~MyMuv`-AI>)?JIbyyj=!7{PPMLA4=>=aJTXNMb`E0@=&_@UV z03WSzypU3+O;o7PcFF6JZt{(jR>|JC9ontyB$MhL2>$>OtyXv^NOFyA^i4BRwb59% zH^}o+>Oz}zsZJ$EM+#PWJXbDn{F+8TEjlh~#@_SA*Or$Wy4hm!kh@hlMplA$f=3`s zR}NT3Ly1y$jUNx`BVM^=J!8qe$V~^C;eQU2?U3tEHi&$~hsBPM#l8`#{UXB^5Xyn>tT5)-I7c4j& zY1I<&Syl<`57K^=N_<(>80yFBmUc~nXJS-YJ4>bH?h08FN78XxL8r7_R?Ge$({%fB zXyUY{({$$W7=3DWJGca4p~cl)Qja zK@k(w{cGnu>ua7r>}ynwe;K73U8SQsdi5P>Y+1HrX9({}U{L5k#q`H>JnuW#)j)$#p zkL@9HO^nmrxwLWD8McHNVJetZtE6{5&13Ta0OjCmq-SaNO|nyP^U8vfTWNDHD~xo3 zUo$#L;c?u3R;}9) zBm+FnZ8+Y@_PT$l`H}%yW zFseGuHsM!_MYXw2x|azHCNLzE^{V*pEre4|+0JS@I~N`(vr5WaB_GUE#uEo0tcuSB zxHChcys^K()V>(Tpu1pF*}-jMGqnEzzAI;)JEI)G_)2f+ZeH75HEhXCo@xRV;GZcf zIalm!&zF@_rV)~ouqIgsyJl03n)*{~7fQOgZ97B; z_mBWc`9K|DcBka0njB(d2-LP@-`-i;o2&JuBH{7mr^-<~K;)2py8S75s#v~~HJA8Y z(==AyVdpe=A8pX4{E=}A0CGeO5`V?|)5#^s)pTez;v0+o72WdF?m4l}gB39dKeKif4+iaFbDMT^Z!R-i)G>qHi zNOdLK+}vD``uE#$DomuEiBAxb{Y_^Wyyz&}bH!%m4ZY>>xpkxFTo{BWbnQlQ69@LE zDt$#orXC}6g!2dM(9)hJ%@YGw7Z#USZCoPVt;1nj{Y8=vbHFu%#ZP9d zX3g>%({!+nj3uG9ZQK~%=uzZ>Gr`6yz8KPpcUm&6G$!wDhN8(^1xqPASLm6<39h_R zG)l>nYkO|nmk%M!yRjj*h>f55DEo~2*G@~vvfE=cOJ{G^*6ax+0!Q^YHRfk+Q$p;^@cyS`pu2YCmo5h# zD%#o*rE}N{@VvZo@^U5U;(yreyhGye4S4TM(zLAyM7puRv)ZSx26u?{0!hsCjw{>8 zha50RAL0j+oimiXRo0Vy&exhcLw89^l4ohC#)z!*v8)^66+|gQ;povyOM{j!FMpluu7wOYz7M5*)5J7do+R~En zaZsb5(hq9tl`R`8M!kcGQ8gZwCQMGT|C#CpnzdKaV7)~Yp(-buhA&k@U@CK^Xwwx=qa}zx4BC;*Ch%F^322@xzFCbPa-O`X!kXPF{!>w`EBg%JV?<0gHp>!A6?AcOX2UMBue>0JM~aAt!*6 zINcG_yqx|P+}VWfyE_MM9b-kc)HP=uPml}3)RgTACp(9~KhnIs4i0=xW3*u0YMN^Z z)jUU~Te++owE*?2t(R=rBtQx7oC620E9>z1@sdn8XO`S)wl1}Di+3KMI0Uoh`C%ZQ zTr&YQNmpwSI7d~iWeS?ytM@zkRooD#P+h^h~R+hI3Ky5%s z5rH1jURRYYeq1>FGL)~Q6T}`NXI;6~t}dDWA#{}_EUb;8K>k$o$LWgW@q9;%Rzhyh zWt$uQSqxpdYO6bU7NQW_qiVq7Owa4~ucXHn2%S!AiQeBi{3)clWn%hSO9@ikbb?bH zj2w^NygxQw$GbS>_Vpp^;a+Q=kT>xH1_1Wvtz>MaDlUHleL7=nwOco9N|KURHkC)e`{JXUvBoy+ z=r24f-k9H;s6M6~3-XXH+bS=tiQ0(Z#N^_)i<3GMbYf^89n^d+s@&XaAr~5JYL-U{ zgXv1vXBz>?_Nj(UJgW94=#AVpY5%5TZXaV*nrCy;WRo8^%eaq_SaS zPi2yzg6AnemoxfS(Z0=I(Whl?dZnr^n@h*}ge|^DNEM~q66o43yR;{Gbc4+MXDhKo$$ z_4~Kqx@5lDwzo>XcM6DX0076ifmq2fXFaT4wQ+L0OIwF6?!#pQ@x>`BaVj_h20@$; zYQd={BvjP=HE*Zbp*MQ_zY*pSIH5%;QGhz|dRFRMBARC?^A@(2)~;Mzt?LIacLj&M zg}9l>5!dTiEQuk}+~|LZI&P6^eq1-&h00sn*h{UUEwDmC0V5?qfG3*q^5>H1CjO>g zrQ$oU4r;coSt9nwQE<5}TH6&l3P$Cr1|Uf7F%`*+1f@P~OdCzbC{c==})^bp6ZCNbFi?H^myS7@78FQ0x2!>p);00$chsh@NcMgIT^ z=;>)!miMh&Znz6l{L*$8K=ddMK?L=s7wB-r+F4)e?rMy#{^<`kjewPeCLl*5 z1kbi>M->xif|;$Z>CD?Sy-lwzn?!n)>q;ppBLT2D=MpQQ<&2*cXtZPKy3$teqUG=M zQGDr1x_O^4vZSPKLqr@BI;$P4x)Fo+Ljp9XJk)9}zjDr)i5zk6e zsHW2~lwF-I&*BqWmXf>8R>t2_(e$SO0GX&M02HqS%iK(;nczx%n z)UFY$zjED`%Jf%KhuiXzY*Bgv`bA1O}dsAOs3_4 zk`hc2JOMnK&*PKSkzJOxO>_7f7-cI<&^)9(+P0RPh)xeN#yi(iRH$7PU-26nCF3f- zySO4jN)l40%<@lJ#W>+lVaV)so2KsX8(VH{wz+LhgdyFJN|P!Ml5jo6Pr}r+SIJ1j zWt&HZ+aDU%qRVMZVYHoxazT?ZgWP*o&j%zCxiT;LcS$N!OSoF!d0;Eel!nKB+!T%? zxqpvNnR3%K{HrexT|>5^b~kEqvwqAB%k=A4H$UZ7*4HIPgL)Q{|tB zM&i`qDHG2_S;rip$b^f`UEgWJt7g-1^Nq3+hn`VNmPRAE{VUdk_Sw^R?9#T>?^)Ds z-nqDb#SJJGpz^R|1V%?SaB0r$=(}1v9Sd5w*1SS2-C=CmsY*b&^FlV_ON0#V$JVx& zMp8)guO5COJM(FpL3PV}m0E{Tl_i&w4i59s@t#SqHdtJl$t1<&4;DG$y;n+R-tEv5 z$HYHkg(w?m6rl~Pkdh>x#6=1Y9Tkl`G}Gd*652lB#c9_KnM$3uWkJNc+JuK&T*8EM zlLS+TE4Fl2&Y}H!(^zGx(@RTH3R2y-+EE|k?mESKah8gr9cRXf(k>cOA81-Svf7=u zKuJz9DdY+3NzEcy+fNpv>hkS|t`f59ljJxSKqxbk54beB*-N9Ov$$^cE+MCqw+AJ( zVEau{b}_==;!vZpX;8pX9Q`}isEQ$Roy!}*YJDOHBfSr@kwM#b(CJ%B9%9Uue6t)( zRFz^w@3569XSzy;Pqj$wcw3&8;R#pH2+bijC%t=iB!D6cPE7zLYD#G<-3nJ8tZ`0+ zYg=nfx`Gn0UXY(DCj;+EqLHB77FE2#-~*VR^wx$o`;{mqEfqLcaF~!HhGzRLJlC0P zvDOg!ly;~dQQmtB3M+gnZGw`7mfAcaFk+C2Hmco#gt}a05~OY&JAG=97}scd?Kb}G zGUdg)ZH0yq4(-4BW`+ecX_|W2I-kP;q$6~%D>#h(DaKkL(!Q}n+5$@slWyt&btqC* zJ;cr@wM%x(QL~!0E4W3&8grg&NKdIPM5ObP_KJyyqGxF~!53FAT$Wu%(p$EC?%a8V ztDICRQDx+Kwa*MZ*kaMEe>Jj#tA1RQDcpJxD@7#8lR5tY5xVR5HhP`;7mg+61to7K zONsQPp!BR~vO6-`xL&a9Xae!1C(PMpZ){fBjuw^1C$z|cT#8&}Od6zS*<9PXU`EYB z4!)x;xK@;m!BIKM8T;2R|q@Ai%dV7F52Bs3^E_)>?g$=+_ zP*%tvlpK$z9Mxopv}pER*EPp(d^X;gt1$h#SyEg!fGF*gw8`uUt_jMSn?)ZEY4^Hz z>lIlysIcKn&AmHaASMC|y^LZi)3Q<6CCyt?vaxSdLfcD36*pw*#@tGflg?%%Fp<@WSI)=9l;*^d#*Y=btLsd=s_Bnz$xF&< zWT8{)Qo?hzp79m$c=(bvQ8e!~hOJ4v)Ac7VJi?;mY$`*3#U#pyXqxNGi;|>M$H>HA zi_WWT_)AVVc9jqklmv$x;!0x%d8|Gy9L_vhYr{S<({5B+)oq_Q2yIRvTapkUKs!hE ztYwcwTW3q)y9-|$*sj{&RYO{B+KLLU8<5(t4(_5O``4K-G5GmZ7(Fr%4|oRg$KH6~ zHX62ZOrhnqA1^QD@SMN&^kC3$^wX?B-yTXi;#pExqwQltctg&{+v_pd`Ll8dxkIxAgR>usr) zo!*krO9Y78V~GCs;^fE49MVTJ^Jc@ub|}=HXbWU-Qke!+RVkS6G5XgOr6&fAlcsc9 zjoU72Pn(sg?4e#;TS-bH60lAtc@@!uJR@gpCRw$$Z&I{nls=|h4xFV0Dhi$DD}mk! zHPWWovPmNsRn+XYjU~ZwTDiTmc}QKURBq}4Bd0U=uBgY6%A2zDA4RgU7E`@4=aig(r(~X_1tj77zuqesE!1VBqm1?V7w1zQMg{hgtDUcWqs^rWi{JT(xlQCHHpl zU>-lMWtSUH%=T2%(r@j6Rmu=l+MZ7IM)dK={{Usha=1zC&E57bO%F6(b(h?Hvjb}6 zB?2=YBloVXPLrydu<>ZP8cd^Z)0BujXX##BQcTV0TIHR_qT(EF*4*@x-1^oC z#z5)Ty)O|r7IN@*Vz;D+-$la@2QGH41I!=E3z4|5wm22mu(?^(l|-?pU6kAEEv=Sa zb%U`>7~D#|Bipd9d-&N&8dr%aVUqQ3FvUb%s zCG>*3dxZj*P@#nwz*aDQvtEQ3#kLl5cDh&c+`0~1q0{`uTf2ayo;IGN`_a#v7xrdD zdx(8Vx@pjm7UimmNlBbR>VB1^;JDoyaM93QYKgYf+~qbto=4@o_;(5xDdp zrFP+5)t0HFFHzLpb4|pXTIww?ytEcn5JOS6B4$Pp*00u&aVESqPwRlC5O_m@pu0Kf=J+d16>#)#`&Dte&5)O!P>j}k{U(Ip?BLt zl`xZ^@~&LiRHbo73gUH5+BCc8RLf^%d3*l=F3>mwuhzW0*_Is}CjFW2Yg;bMHrA^u zw*FF{aHOF!K`Hm+rF3}yM7XKGiqkT$d?sDjTSdgFFPTe-{{XckAu-Qhy{l}#Za0m! z*<2rHlX`OObZ2c#<&?7MUznVFW=NXz;g!wVla~`p&qh{{;Vnm4aIp=jkn`?B0W-BJ z9nWgjLp1Y!f2pJ;2}JW7d+YxI6KSpAo20(&l9cfv1T8thGt>-yE9e#;6=f*13scq7 z<-5PcOUF=g(h%xa6oQc^3Pyh7yC;D-+9@y7Ah-*PSUY3|`b>V5o+ZO#;&)yV)NHgg zwWzAqtx@+krOP*#P=zOK1gQ1;eznfH#Z-F}(EHtatz|AeyLN1nl>~+wKq+i;cE>g6 zTU5l^R>u1A`@bP+ zaW?5-mpr8b%98RBw=*hZ=E7Y!5LcrZymq1cT1$uU8D7 zIMG~;>n9_5Q-!zIvKO&XQ;sW=SsQu;><^cBwpw$`X(}pO5@Y2Yk^QP&$xz;r&brz! zFB?l&4qRNm_SVpr;VsGM9SEA z6}H$qf&!N65$kPH3rHui1lK(ALy}VVWVXz$b3#qRoK@40`OW}AaDd<=JDl!gtvnJ- z>X)->`xrJ%+BvGF7MhBf2}b7@RuzN(8Slk=u*A6AHm_%;XwFz^RtjOjoBsfbN)}e+ zk&nt}GyedPuQN5NiMucSEw-L5FBf6vsl^l_wocR}K_n>hq4li1jm1$dw2g}$E%$A0 z??u}vLoElJEwwS~h&lB~ezbV)xYx2{CT;0%d?v7qk#fz$t4ErJT_CpGq@R(%Bq#gz zii!BoB<&g}Ph`6P0Eslk=tA|Y7qsOr@ph|16XrG+oS0BBk^cFuABoXUN{(5rPgJ(l z8BU%oUU55(5OK(xMb;8NDU_wj3muM$(0IEHY zJXb2f;Vww&tr!-*JYz#QHg4KGr}%+x1bj0k2}_@pZawfp2Nmi=%W;nuiQw7H_?yPg zcv*f;n*bq0%ecH*l(eN_LPi1Y?=|A(@c#go+}{5H!lf=Mj`P97)thhPUV60)rL>nx zc~Vr79+B8)KK0_`#O0TaRU~6}k5BLg-G_@b%ai;H%T0Suw+}U8cv4Wpg1;do13c$) zy{qhSylM*HMv;lgEn2UL^>y6dySb-A?QOsb^AZ+kYC#^9fjIluo#bXyxIx%`Q68zI z>B!TrPPcgQVSv*hhKjtzrw9r&02L9sGn(P?f8*sDT!G0g7}grHd_QKkEc8%pntT^7 ztkzMrLQYaXU^|-ns6k^?MLd98wLnV0NJLC}cqTbK z*K3+k*`#t=m#y5jrMmTvs4le9i`(unLu3O#KHxf;Z-ibm6`({vWCSxuVl(&E0B?$dA_g{vYGKM*YO*BTLm$3XzG&GDP$@Yf}#!p`qpn7Ywy^jy-02A zHf`M<)3<8A2$0Hv+R{nJ`OfaMQ!moKPiF3uqG~T$ zBK3B;gT%#Gjf*VYr$7FUB~)hV z-XPPhwYOirxpLXYZTz$;4ISaNe9(nNk?&o&;g(Y0L&TB7YBzRQI?IPlL)WZ6@bZy% zKykzo2~pdCXD}kZmM~OJJ2souZ*+YY_e#95w7qdoC(Bq=F4*xZP&vm+P880#QPb&K zGSa;{{ayE$aK*TJggWwLXXW&cJJ(cr#cbVDH-@#LYG_Liy4B8>^Cb)NoGX>9pLECh z*T{LerOnR|>CZT}%lb~Er}%K)+_o5bNntIdxIx-8iJriF*Qeoml2GH2QTq0EnsbB1 zT1~y;E!4>J{Ld}FR1?<&0=};ll;LRXQ&d;eG<$?zxpR8?yLHG)b|MDQNdxPj+O&*a z4)k;ZZ6&EgiVH#8<)BFi-mRxWWVd>2*GvadaE9SBcPb3_9q3=_4lK>Ov31wk^Au1d zNlYKq?5UOJ$%XF5Eg0>V%XdtvaGvpQ}4-xj-sZ z22f-Pt0J~k(iYKZptmJIGSVPay_!`cVS|iVNLljN93ym&ziOQq+08ws>W0y4X_nDoSixzp_fp&!aYB(|V3Ngd44{CGJ1i1}>R z(yyFq!%tJ%xK)jzQkb!~c}NU}D1w5sl#wuOZ#+A)|YC#My?lS z@!|3%)E`sJ@xtF_#k5-S33alsCg57ythSZ6ZZ@fValTInyjRcv0RDun z-InCr4fdI1tXef^a)%$Y66+~#B_UgKc+b`;_;Q@`IZL8jqbFR~bj>2s&nr(tmZb!; z9git$94qPGzMCCgSk#e$tS?u*O|$J8RSA4$}7 z8?@_o{{RiBGjdgK%WXszmyJi>9kgY2W^B zaSo}*99RV|EDPt#Q+Og(}T2i*gczse})Fugnt3j7Q7cQ6^1>F}@BkdebhTqPEOeiRZEf7%{98)_Noh@pZCyd` zed^LgG(~xDVW_m~A&5%HnA(yQRsR5ry{O=rMhvxWYSR`^vMpLovXBX734lJ7xWux# z(--E*Qj&s{fY}4n^y~W2k{f3|;|(e6ts(6_%X?K^xRP00Km{yMDpxQjvz$GU(dQah zg1khXuY#tn-2PH`EN((leLK74^sacti9H^l;YalyD$zEVC~PH=r3JREI6MCU?z&={ z?5js))yZ2M(u24O0UQBZazzyGP@9#7AqonNmB$rV$d=M7I>2>7w$_rU$vC2g$i}*D z%X{M1@V55uAvl9kL)i4*INL}o^Byn(LR182nkaN=A@CFFNgGp<+)+SLaVbN~36nW0 z825eK{MZlYjbr6)R)7Nn0t~$~p zy^m?9Ty;uq!jO?AD_j6OMLG)|Z20rPnBj1`eK45Y?N5splRs>xj=+5+`jObv=wP>H zI(i*u-aMyQy>KJ#KfM4~x!n5Fl-q}G)D#_11JfSWN}8fNDUB(uI^89^6iFmuBWxZ3 z=|1(J9xQ4_0irbBh279X?9>#67MN5xy#8M2ze<@aD%Z0C-v`|<%)MseOGzBMw1U_M zWk1lxCj!jSui=`bUQ?(yOs~xW=E~aKIEnd{>?rX6~l&|}8 zOq8dnobknE`58_x(I5QReWcrlO}lnBq>_fMg4U!fl#qSE>&dQZ+j=r~yDMHV;!>6c zx>8eem8$7B>JO)=0M8T3NHx`oG_9H@sLi$4?=LTlK&ac2N|;k%LV+@_^P25RRj_tz zS!p*{?j$vHZ>NN{xh<)%rM5{Xc8(-~WY&C_Dn>m208GbxKX;=N;@G)z{c;s{&_Y^V z&#M_E!O87WJ$6=^lWpO>M*V?$E)dcSyOPV!1#j!QD*pfv*Yv1Of9i9&MLHMoceQJV zUVhTq)mxPzrFnrWS6$&Fl#U{aIaRZvO;J}@N<1&7xV!yCT8DjX0F?m$0B}B?4Rgj4 z$W9d6glT6t}i)obMet>MMBTYqB`e(dxbmd*Ms0J>;~t2N3cu zOUfjPJ5CJr&IM^G+M?pqIG-5YT=;85w!X9Y;da>Bbm>}rhd?+02~i+*?m4bl;^ORv z(R09lEz~t@hp+V;6x>_B0zy>&&_Vg2r!sI1_N1~bPhxW8+0ytyj}A9^sz0gej%otg zf>468LkXEzxl~WQ3h9LYO`}-Ok;O5h=r^f!+BSCGg&_!XQg+Dz0&)m3^{#16r$!QX z?2E&`2vwECXt%yzl>XAy%GO{2G86$HS?^OhTF{h|CAz+_@Bx0+EIeB+l{6Qs?wn|jHZGt9pP^9?a8sNAz+>fJ+t ze=gxeX+lK7PaN?bYtWROqfFJv^uGw{r%hVjY13-AQV^tEA`;jn9n;WPft5*0mqs#Z z<$P79wP|weth}f7E2p97S`tuX!Z!Uf4RkzESnS6`?5!1S(^eX5+Y-B9h`4d|1(->K ziIM8egWsi0Vy7Re(HQ;>*8EhabcEX|Hd?lLwu{utU05R?W_?C5R5LiOWsN{taY>MT zHIg-}EBib9ODog-#I%&Dw*cG9Nsyxx%@DH~r_p!9Xt(h5&)i?#zT#PNUX-M4Pnd92 zao4cxTR3t@TU4y=wH;35Q*1Qt<&ksCC8a4vE&v3jP)AXL*0cCjw2Y|Zth5&{bq4&k z+g!;o5Q$X8nfK2hy<)zSqLOw&sd#?Y?LK>?>B>Yjk1-*}(BZ+{B4Fd`U5XshRB!l? zKx<6!>n8Xx)x&Lsv@O<3T1v1$>*|0?coB-p;iEU*981sKSy(%0Zkt0&aCvA83iA#! zp~(8yu!R((?4HBJ8n1!cP1dPyE>WmIC6d3;p#!->0UN}E;toL=anrTCyhK2W2Z4>Z5!H^w5L`8f(U{XlhcDWj6At0^L-H( zy_4Dadd&jew%SUX*ngBbAdbDVYB6~$K3yFVraOL+#;U^?t7)rukfz8=2n`d7_vwoE z<%?T1C%baZZrk~G?s=@CXmq2~CZ1eBw(02=PWgX8|gv}$R7 zB)7KGHHLiV{{WhlrG-7}bw?v3?H_v2JRF{i>-mbhHrVy~VLcZQ$%lJOV~J zo)E_$3-2g*2v;hFsR}9d_Z%l_PHCg9#n_S9U2m zZIdjqi=v)|plgrl*Gbeg#JJy6++mIV5yLYR*qtzVQczUPYq~d@Z%o z15KoIr6lLwCp~$s-aA$ki6TMv+U|F0Rud_4#f})Z{4&`E%3jS|w%DBE4}o2yGjiWd%Emil=bwI{{X) zIWm$(t7i+h$SrOxEh#&Q^rR6S)}I@RPLc+hsyCuv6}jf210TyZA;wlE_3X8%T$?h<4k;T(R+P*VMnK~n*ED>WIhjlRI7`x$Y8r*w zpLNS6xLsxYkV4++x(`Blj90N#i2lb-;7<>?tTf}Ux{W^7mF^ceL^hO2gURT^uEhYDY z&zX!M4!e5IPDm_?tbKYRNWFEbD(c$N;dGU!%>Xuxtma80*kXEDn-2xX=FQx+X*$i0 zs?yMfy6yers6$OQk4jJnsbyXGNCT;_pz*wPqh?KVIbRj{cU((J(pJAsyNAqhx)zIN z=V(#L+!8p>YtzM1c9FI=qNvR9{{V(`{TD>L)NY-AbifW|gATa>`g?N<+z4q{iZ|hH)QZUVP&2(OhiSMT55rvU=T?oAXN0(i;#I zp@Ssg53OYJ@|l`nrTt?`xv^^M>fOX5`G%CD%4J1Fa+HBGqBxG#x5nJ4Q<93&%OQ6b z1rAxfZQOBE<7DNvOvH9G$GuiWlG#0%93txR7izaHJdg{eq3K$W1ok+u9$8#nA?u@K zMSa~yP>aCU&I1V_Su_-nf@-*t+k8WORM`N-6W+p>o!R8cBEk|fy#$cd8qO^C2{P<<1Ki1 zMz?pt_u6x*DqXGmLoc|PR@HVL&wB8D%$Z(nTuivrG~MuZ)4Da~qJuYAx34K%oOLPk zo7)mrVlX+1>+y5XCz9b6qoqZ5dDYk9s{;8>p=nvQ0k18$5~M`H$mYJSWKB4}%hyHs z{3UN~dwDPh8Y>7p?3Uri<%vzfY3UQDL6xZ6x}J3YKzXitdczBoAoj zHODny4eEyBdR^10M;6W?rA|%~vEE4>aW&^QqnBhxF3T4>0~)QmnzdWDm-h{qPSQV? zC)AzC^GTdm^%*wK^`vLn_$kzQ{{TTlcFkR~oj=LGcI2psRhd#$I9~=uc^*{p!VWBH z?CCsJ;1+fJ?Ly;HN-dqaP;I8IKvwn)Sx=f92@;hkbP{vz^s0noJde@M9rS2C=8bcpq-t8z&kIGHt2F6$>3ZVf#Dlg< zu#p^^*Z57_vwCzvb*tZNT0`z>w{7XqI_OAp=(># zlTT*?`rjIZ8cp5R-LYs%c->1%Z8%h8B%Tj7^iqnHoRO@f$>`hFbtUNOQm-BdPxAbx z(uD3?sW_ON=aX5=E>3}CX9J}8?OOi;i5apfX|%fT*AsC0LI_ETD(FBT+P2AsBV?F^f!>U&Srt}?DALhN{{UFE*L8cF zZ9OY)>^JFg!bZ|eLI+43*Po9JaVusH&SzI+Rq*Ef3&t*&beA^1>z<}c2pdWW$T^cg zrFxig0P?6h*-8%fQ0^02c+<8n>Kcl4o5>`^S&HI_Dz?< z+(9Zr&{8A_Q=19&k~r_pcusC}-$qVWV|d$Kx$zFY3u@g;2uopBs4bzw00Kbdnf+_2 zVvMC}Xon74Mjo}HYEQoP_3o`%mbHch}o6@g5m9n=&9!r3PsQ|7F zgTPNBe@YahQks`V{UXZSPPs{X^^}L4Q;B_03xkcM@JTR76>g`|v|xHBhv7S0D^}Kg zw>2~rzJ~7ZH)I(yt`bK?iW7>{E}6<{no~NSvww8jH5=Qo92V`^ge3*V5>$l+81nfg zT+bE5I5=B^yEAE=ro1iegL-ANH?Ci*=!EWTdr54>6~`)>fH><~VDV!=ypfYlp2y%L zd#33YNN(-)-v+i^g&?+>1_=o{{cGHWRAa>*xYo9Ik2t%5z0J=P$nWp%S|vrY3pAyN zgIg5Z3g>?5GJE!*mDzo1Qx_pYuv-d~>xC26O-W-*xC{nIa&tTPe4AC zRE(cvZ7zacM1>N1kxZmn7Yw_4l&C_~2ntEUed$S=G|D&EUTcmrg(<)=oxno7`_sJ+ zDc;I9x`OQCO4{0^0A?nGchJjgx0dNjTu5*7t9$t~?|0lzTH)MNIb3|DlPG_{+hu!kHf%AA6KdH`;#rs`MMRxj!I zw)TxDDhf{R!ZEadm5groX%eQa%eEE|n}xY}V68Bm5+w0jOKV0`O`Z#_UX43Z_~hK6 z35%Oa*yhz`B_a$*UfkC%?B$eM%<6jb6?mI{LFKZAEI9Iz;8|J}eIR!{RMk5$a5Dvq zHkXNY4_$mV;-J>=Sx*BWO4pXCg{C!kDzsW$LYAh&%8?6_al!3cdKEj-e_8Qu)7I9u z?G$_}VcouAiu=q05Vgo?72kx_~H80(%TsnT~T) zajg*vE{r>G3bSc^)#6!h?#T&5cMZPhmK5knK9kVIdl;`~Dm8brR}{;SU)kH=x*j2$ zXHv7}ws(b)U7juaEUTA8@de1t+3D04$GzeHH#wPxmv}@N_RAZr7c}b5>80syB02e46wqkd^={9 zTUa)YUB?o_FCAXrKobf{obe=#)XN)*aR!xq?bZ9MHwwFQVZ83%DzVxq^c@$) z7gk6%?X69=$cKF&GLJ}!;<`ZC(;ss6#Jpc=7SRiBZOVtZriO{4)mJVy#n5TgoP?+Y zJdSy)uzTn$d0{O&7Nr6pslf!FcGsyP zEQQKhAwFHgcHDwzagM1XE0xMmLzhK=FkRoFw-|cb-6wKZg{UAH>sJ)fl3F)Y;me;f zPFw0kv`|}874nnOU>t=BiQv}iOQMoDw0ldvEwI_SUZ4hd#?q7D{oZZ*Smh~le4W91Fe*{Ura6=Rzb*7 zqJ?J8mwNMfTZ(ZiBqR~?{p%*_m*~~CeL~}6LLNpvC;*iE)uuWjOY^kE7!y|_QX74txp#OUH?J_KB38-35&jeUR1S=NS4&0K#+1uy zLrObCrb@9NY!gnHSxLPb)mn>eK9sZ+0c~kX2qJPOU<^{zDlD(5oflDJUy>9qFiZrj;Uy64%&i-$Q)o0G4I~9_|qXJBS%ot^#|<$ zw7*MQqaXurl|WWxkYL9Ysl~z7v_qoh_D&W8 zmP>@^)dQ>v;wwcpJryqWbDGtw{w36{E%jT}yJ*5Te>i0eGXXF%0Uy0@2ysJ6ori}k zKjm)@d1|+~RlA5FC8u(jIZz+G8k%EnofEsN+&+sii-z59LXgdTf@yxzNbw`{CkL(E$cyCSbkBw&L$D<*X;zA|TAO*|9BrqD)d}GP z+@AHxnlW#)YO|@-o4Nl0p}JMY(lsQslC=bcC%Vu8Ga@-6w@~8?h$ZOF)^$g93-Df2 zOYJrqQWQ402jz(TqGq_-l6J(=sb^>&)7!b!FOc(c0Vz~3Deu~3eNA)DPML%3cByY~ ztJvRK3~AQ3=~K#B8^GZv4*L^80jXj14=%p8=v>>RM%^Yr1KxblgG=W zrZS@;rCT*(FK>f)T7A3zQFI_BAtaI#pn971VJ=;pDc@(LuSM|2v*A>gn;VAE1MD)} zs@kHQ7*{ATdUmeJa78y2vW=b1wTf>TLoGJ@f)ZSXf{24N^JA|{iOqU3ocSt73wBD@ zb*p!nZq1h(Z^{=dD=7(28^>}m54~`6X|{+_kw1s8SEr@xZRsdmlH-64$?XT36~!!$ zGvsKQOHuH>&Y^L1r`GsI!+u+BrC50G`GkDR_ODY8X31RlTV zUL4e%t(msi(Wq(~?T5i?4Nt&YDJZ#V&By=W0H|<%xjzf#18?__rHnR?2Ol+f9WK z4rJ~pkrgU7thl>IUCWm$*L<%bWp1Gjr3KC9N4Pb?1oKAdo(SwT5*m7Ua?9j=5>#9bV4*?We95mqe1O^8!f0BaWG_ z>11`IvmBLd!nIe!xxA%Yl7bRcFra2nyjRV*%hAr#I!_KZ<>mTq?ZVuI5_WvbB=q{y zh8anMbZK~t!|Yoo(Wcaw?h2Hmv~DC3orLgWx*Rwyo5fk4$Av9*d%~N`#|GdQR+P`A zWQ2|@qa0ftQnDCjyCsH=vO%(!sjgDY#-uns5sRIdre+)Nz51Fv|B z=fvI{veO?z5XO|&%XRr+ElC141x9(A-gzlfW>+L&UFzF!Etz>i*3ij+%0j+OKm;6g zrNPQJiGQqCJ|w%c9&-yf*G`}|+bP_oXM~UJDn17%vgx&=^By(1VXLcqn-gVwbUc>a z3JFp``H8I-3eqvQj>|&Sm!@2NLyZ@#A7xCU<%@MVl|dVVlsG+p)vv)6wvFQLY`v-? z=Kla#7j{k^ISVks9*-?J^&aXm$9kyJ(X3?@U@KZ{Oh4h&)2y@RnOr z$}Lvr^SvQ3LhZdI%D5Wae0;e^}8MiYw{{Tkm z`pRzER;1;^+g-W&5>Db`CVy;KT%9{c30v7~PPJ+6UfWN#)BYh&g=|VjR{MoTxBY#YlZTdvG0WGM^A$okilEEOQtvzs{_1liRt8uiA#IMwl zB=^lYxjvbkty4Gcb(Za}i%uiWx>xLvliv;>m~us6TOv(rvzrg8e#MM5@8}5pcA$SZqO7Em z*=UxY9CF!6*zd)msXnzGuq44aHR#3hhK*{Glj03J!&WQWQKqScrQa)d((L+yCy9=f zW0R76jO9gb4eR|Oc6x`0L#Ibd%+$=NW^$71!Zoh8fC9Q)6_r4+dB>Z)mGqAeGxj=t?q>Iuq?! zWs{EmisEUb!IwTNRmJ(gZqCZZ8%s_~l_b4hV!UQxzRwR1eGcf{wHc86GNEfa3rtSJL(ipW7JiNP7C9Q=Kmu1~S|g@+$a z`hwDi)Q?yaHv^Feo(C1jIm&Ocw#{!2YWEi<+s0dUrven?u9r({DH05b^-NZn@=F_5 z%~EAu4*vjD)-LsZLB}`Qn`O6d&C1F`W<6W;1L<02=aO1x_}2D4gdK9u!OcreKyuBb zqhj5at!Wu>kOULZ3iY8BqLb{~jUA1HHg*hIx|OX~sc`v0O@I(KZGd`+JlDv7%Hy9a z^e0PYCY@&YOtBhsPg~yFAxxWqqNA{qlM%ph44dQLvHU~|hABqy_<@$*S~(Va0ic6ay5vQv%R`J^o* zz){;hBv-YG&!#xp<&SAvw!|*&<*LP^8w)BRDtZK**Q*$+G)6wK7isvTO{*y(;Cvj+0x%t{p6&9kU*6rd!N{{UkCSKOM%Hft5=(zT@x?x;B^f|`3hNZTqvNZHVE7k+;$$->?Yoclc?-xhP35c zTcvCzv?=Gdvhv*s8;)g4BL|w~$rkiNO_nb1F0L;w-F@VjPXH=YxDV4Nv&RX;Xs$G4 zHmi$mLe^|k@ox_|YkA(Hb0Al5DK$)kPUk=_>ZAC3VaArfJ=Cqlg|wlGksf&_~w1?3rUImC1AuhrGN)j|?D6wA(O+ex&px`= zkn30XZ7tu33Mx&+fK(I7B=dv7&3b80O3|mSm%KaUiw_T6+v^S`yVNwY&}nM*$xMeJ z56XX9s6tovXFWFbb6U@fld3%1i)n4!rRjCRk^{zPbPwrW(88-`swzDmt>9fU%Ul=JQQ_;2IHCo>{eRpK*fz><~ zqWr8Fz>d-FT0z?-LGsz%TiYSl5KD?HRFm9wKWgbl)N1MaeZ|GXoL<3htZXEMjt}47 zuAA6e=;nMwsxaHm+WDomGN4ImQlsoU(aX?r_CVgdF6w02YFVon^%&6y{P>GxevSEvD&Dp$-z2JhKa0fk^!Y z8Wzyk^xue53Kj>hImiB}8egPNS_?P)mAuoWry)M56vY1kz$GT%c{?Ye7&V_@V%@19 z5)|uOoCDHh{pPI!oZ-3N+7J@r0;YQXjaG+cmK|xLscl?beZRXs$M|P*QgQj)a;0y3iz!rq#u?hMR2VBPtb088XWYbpdUqyusPYHCDw# zJhUl75ETd0zoj4p_vo^12wN||yuk<ytu^SKNDI=U1Jt;Diqe}NvMvbPRTwOBbt3F$W$$(A*XW#qQN<)|UbBplC ziL9}Ar$20qWvroYxWckYCmYXM!~<5GU$ZJWtxxc0!n(DJ?#kX~;TQ@k+w$NNCUe{G zQ*e`_TrA-)zYp(!oZg$L8>^kLq`C8q{Gj)a)vCuH%w8(lVUNQf;a15nF7?@!sT&g6 zEyT`GQ;NZ+nWBP9=(yK|tt`~)^%jwEfB-^9Bcw%+PZvhO78d&G{|=$6`ot}WZWA-9sjOrdR)24jLN*M~;1Y}t3l zx4t44dbPWb*cL%;cMOR{5;y>a`(~hXPCKkP9n6{1GR&0Ev^DmxV>yymT{Gu-T?ITedHJ zG`H#Wl77DA{?*qSYi4p*$(U--QSj64>JPHQEtG_o+H7wsP&}A2MR4XxI!HKb(Qea4 zwa{&uU_O->Py+7O$+$yPk%P&K%Nj}a3!=~P%LFpcn{1nNsBbSPQ))q2KPW&rNb8Ow zy%@=^i&56fe;$_^dfx5QoTKJZ&lN}-(B)h$ zrL?uN2~xA=0U!KVYD@~3?p(Ka(%VaDDlzLa4`J^~*mBI>u5i#|m zOGAAVTH9S-J~a!b5o2;j#J16xKu7=&?>%O-Q9@SDNAxzXG^IA(!kcmmy#tT(s*M2|LqJ^954XVlYg*JqQfKLOG0TIO1sCz2(box3RLhY11tDAKofRgD>;5zrK zp&~1X)pK^Yt(tn!GDs+N?rB-U6=-c1#kssmSqW0k3R8hhRETbx_&`>mlq6$nbNYMG z6pBvUgeWL(;v?Re%1$zt)OREV@&M{+&=A@N+FPlD8(H7DlA}JRV%cXqMMi-lbrq0uJCY6jFO3Hf-ry;AP!{*JFqT5~4P$ zog(YmtlMe2vQmPBZJeQ~^p#ID(uYA|Lr*xlRFIUyb{I;#nnc+vH(piRQRR860s-7$ z4)hd@ZjUrLhSZ>?4v9FP#KaKTJkg0?KzAHeF7ydei)*V~u=e&HQttfFRPl^fGYP+3w*3s-p@S3OUa*-j|KcK-lR zy}MNKrSPr4CmXeXZGXW(e z^CLZ`xiak$CW`vi{;{aKv8L#Hpt7}EWLu>KBrE>kq>x~$Kv2drQRBu*Y{hq?yLtnf zkh|1E9B$B-MQn)FMw6kiJDNej#5O9`}{mpHL5);2fz74ax@qVEF#q+G&Hm2b=?LtaaGK7_N9^$g{ zGvkV?*yPfQA{FMlaN3J&QXfK1vItoO;E^A(`&W$HmeV=A*?rv(>rvD-A1&oswP$WT zmE0YOPy-|r{{WUFHOi%tONuM5iaJi5_u?wrX4y=&aMHq6sJgJ*EhQjHpRZ1}?)a;M zvXf>fi2N;UqH6EhHR3hu&4iT;gs`Nxmr3LfsRn;q>synsm9$kJ6m7o`-)cT?_ZodI zl%#y%^&Zuo?W2`NC$eoC;_T{Y%16rv?+20d8@P9kf9 z3NY0cih6Ce#l`E*rp18ex$~|PfPB5V3H0z{2nM?Gc`!=7n#Q=>ENH1k-m0|Ux~m%y zO2*;>P~7BWf_fV2jO{ueq>J~~T20oRqRWZ9Au3&~*iwNhAf6|uT-QvXX?ipDeFdg7R{Z-Z7yQ(Hurj`uj->q=@F_TTBpCe6~7rNQ9NlBK)%W6SWf>Ngw z#z!AhUMw& zW2foPTWS|AzV*Xl1T=#!9o-M*oC&W>7m%_#8+?@%we4B!CM~Q>A%fdwrMYgh1ArMa zf5j2UYV1(uBQ=gp=(OE?;}Fw#HzR1sc`+xq93SggO>lJ+rRd1Iu+nZC309cp>zfo@ zb%!=M)Su{jitERd>rB=zG;^N^rCqJ&S@RuRX$2}+lG3IKB;=2ASC=z_w#?ghYU)~j zn|}z0E*g5}DGi%&*(xdFIsW}C99~Z}+cboz-O?F;%HHjpfS-hYsJFLo9!kG41MDlF zS)$pjsz}Fo#6Dfqc23=1I)(a6TVSFG%$UUEitSdT$dx4?&Wl*^?ZwZA&ab5WOXl6g zsdps=p&bXhaa>;{ayCTrE70w2ls~5V_crsWw#rtEi+`2WoGN|Ae9Yx1mGXKyoYNVl zwQJ#j58GW|A#Pl#!(pN7GB_u-bH^;@mZJ1+DJ2i7oSVa8sjXV87WXe)B=5H-N)kbU z2*5EI_OGSE2&H90pJzX7rP|s2LYYgBC8sxs6n4sBVmY6sb;~CdZ0U4y2z|#NNm9u; zPuh5{WwRu0={l9xnQZ0NtLtLrE~T*Q3@9Y>D^%;E(zDR?<`CwN-NJ$M+e^Dv2?R<+ z)0(qXKS*sZ*tGhDyxAo#3@Bzf>s@%#QAJ0ynbWNrH$EXd1g7Q(up>2&M#^MNfohhN z*PxC+TJij@%w$)%)~{ODZ=XZu4u)2Mu#gVW4mhr_9WDsO#nByGFO7;R^(7qsQ^>5d zErRUyPsA-w=^h-h34K5oTUi6C-5Kvu;6;3l)1-0%<-Kx+EkvtfGhW?&jN!IyY7e<* z;q5VOtf5Lolh5X;%9S36{-vAsl`Y21DGLZvf`Br1oYyR3puVS+%#CHVyJ4npmF`JV zl1!1scedPPW<@K85Ij1UM5V_sQo_`g5K0UZoOGy>tWl|JbnULNw6?E90EW<@6qNJO z;=Gi;!Ify_HBCO<{{S)7v=re|0asXx?Su4Z=? zM!t+)S=BV!E)yPlR039{f<*JpNB+#_lG)aNA8OZ^PPwK#a^kf6P+Vr(VF^(pOb$=h zy1R+8ONpw(NpnxQeR8K!bhM>PB*2qgFS9mrdN!$bd#PSq+&o@o#ieRPfEhjOvMF#X z4BNWXZFL_M+a}?JI15202Hb8K#Y9fC&Ae`+#=U;aWTC57A0+_c5S&G86sXQeplJ5( zd;=@;(o~&*5+)@xUJGxVDReu;U?W-5*-xdn8zo^l-JZSct_`)Yk7a)ZGL1t|)kVrf z;TEN7-<_)UWOg-J*Zx9f*>%k#&e*)uR_H@*S$U{P94=Gp_di5Za9chJ$a=6 z0J1hjmQAIG*+XMu7Nu@TI5`#DCG<4(Y+WR28jhTsG4Sbi!WI$vq?wxVa{mBwJr}%T zX3d_jddn#C+65kvOjcRDL@vx*lRBewm~S4?oL6oWOumYXd26>-!j?jxBgKhW%HY?Dl72SvG2Oq8ubGt<>wGbI)@ zhupe#mfcZW7>_L{gvrUR(o{+v;ye3`23%FUrK0RKvYx0XBCwZe(HYt>FDq0^)TJQ} zs3kj$BoJl=dN{wbI`E@o!OAKrN{Lc_At{1q5-YzaXxk#u(CarYjeUj!$YG?YA)$n% zLEv#-H=dJ@&S`&BO4$jv3QI%F3nOq&CPrqwWwkvkR+()CR_r>^W6xplOZA#NZN6Fhw?q9Yqc)2;sihbdbOp({dtW&jGniHhdT z=%vwq*G92NiFBPUHjIl0-(a}L!L>xJPwQMM+cQk-{Bx#TXuc@9X33z#NPV=W0FnR` z12yyC@;_N<=bvRec2NGQq_Vj!y7ITAD2?8gb6mbZ_eI3;j}*A2=+>8n#mmYmalwM1 z363l2BiR!%yc>4*qz$#xt9^v6Y6w}73{sLRIwaKJah*EVC|Z&h`U0TxB-W8iiJxWr z`aQPq9a_D8lD7(~j&p2v_rPZ^9X4~kUc2(_pheHmlhH^eJPgO z)U_s(g!yfyTT(>Eed$X~=){rex0*GR_P!psUAhZK-bzL@Gsw+!E{J`duYt5%Eh+sz z>e-(z;lvcJ!lI&}I2k9sc)ove{{XXOcDnWJmmV*;wNPwZF=~Z0(`_XQLGB<9=DWOZ z(P+-`4VAcHpCtr>&;+JpPHU=v*l_Hb#g@Bqi?pwA(UrZL+{ghnO+*Q*y$azK7 zq!lOV_IlNFW#(=@iC=c%lIR0O2bo*o;fEeC@xKjw-}L z&;>3ei5)$@ov5%Wu_|oIIgYf7^mO`pAx$PsM;~elU5~l8X%Cepw1c;hC^SaCmI9JV z$%>>Y65k{SiHw|+_ljf@T;kYs^3VX&R9tYyAs1}6lqCq-tRzR~ zJ*(BjC(P)7)W>LiNYmExl5&hjU1|3oxVgVui#K+ylrrYxHV0$P!?(+BNW9)^paDp_~KXfA&;A3z)P827I?&HjwaXDO;*zKh{x zmk6~iC0ejFz+v33v_Rg5S2jy zP0 zN703Cdi}?U9S$#exwvdR2p+z9uUEzXq~q*&jFJttk|Gd~<)tG4CKO`5JPyvtc4~Mk z!I7c4=~NdS1v}NWfRIKeIW^tr=|`bxw(Z||CegRh7KW|?K;k_owQ+KM*=7ZWyJy52 zgGDmhRFV=*fr{u&*_&qFoy(UR-IH!Bb8o(cx`=?VRhb=Ye@4k@qvM?-&dXA93|pb3 zFMi~tKrnk!Yebovc>WWqziDVx)w799ifeHxD%s9zQdGwjN9VZv?j^;Q1{V!aK zMz&}*WY?CGhi%fe$dXk&&o$C%F3qcgZJcnjr8agHf|5Z3dLEq6!_qBidS$h%m!YQi zq!hs1NFQQoLM<&LZSjnT)UbOP=71?_U_GamtZ!eGgDT13)sj6Iuc-)0aK;DPrIw97 zK}Bt}4+JI!wp$7^ zH=bz$nz0^e?BN6H6+lkH)TWz~O#lWznBs!6H+86ElF$l4dDIaopOo=bx+Xmr7)VoL zWO}zm`%^UZZRtq|%LYg&I3{Wt28E7FQzWDOzP?p(WmWM{y5&(q^aw;Ti6CYpE?4HzsUAk12 zxKyOcf_{}TA@*l88gw%&Q_N1Bxoc7h;t#V|b2S-gFl zOHkX(N1oYn-KGkaxQQpcS1v<29Uq7ve@I=e{jJTzcWJk2u<3bf^z9y)B#6n!y;L-1 z9?iSE>x-*4nOCjRmaH9o7-19;NbACV4ZB^kxd9gy}OIGItiUh&|?^J4xy)N0OnbIs=KwXoU z4Z6E^Wwk6K0*ZK;u1v`hB95ow{XM@N>DqX=n=66?j45g6O@5U;+8Zj)#!}vo-ylPv1;5h50CK9EUkWStvJ*!$v zqS4N^e{=kGhWzF1bg3&${K84CVcBPIX0neAYJeOgaZKh2kMpiq{mw~$V~E#ZcFy^i z7;#N4NKBNd=DMTVqdH4g(fy;~J{ zP*XgocOOdeOLK}XxzMlgzb3+E(rO6=xgI#n(}JJCiol|hFVUgq}^HEk2cue z1QZf}RIKex^8yAquetFR*;t#Q-U>oB8_ULST5a~zZM`9FgRxtPl$giby?Dib9m}E0 zWfoWNhEfoakf1pLz~XC*Cu~fEStad8#4kHokb2C4f|`e!1uv%x5A0kvyw20$h@&p%OI5nE?FGjywV*RHgJpG!(kzzjr@ zHODU4q1n*rC;tGJ_{1B8dU5Fs5Gq;IJsWH~w%%>TsuZ$9k8!-$hn>DhJ1Tgl8?7Sy5g`h|T|dpf#WGBq7G+e^39 z1*<7!8@AGRj+0(~PT9|p-O<14SaIgP4!dsF^$txuW>9S7HCsl1i8$a!)rAOBNe407 zu<{#fjo(1j+fBERoDBeg+e2vRJvGUR(xW)`dJ}iAY0a~DZoe+)(fr5;Ck7{sS4K3M z(H41!h<~52wED>|sDf27CTr85{{W7KBf8S{yZs$kwsv<;F==$b^Vv!CIUs`|*M*6{ zm7@k@c$)3xv7zm8Lwl-1fINuf>0EP3^I}O_G%jvjy?*Tvth$7tZ3@g{y#D|hFOaBz vV*^(^l2m?aY)@F4`Z&5Zk7q$^rdr&1tKghuF4Wqo-z<|Gf^cf)Ya{>JPoJrW literal 0 HcmV?d00001 diff --git a/swarm/examples/album/imgs/bekas1.jpg b/swarm/examples/album/imgs/bekas1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8e38e5f55bd8abb0b681173d42c6ed27ae0b2998 GIT binary patch literal 554726 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 I*T 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%0DRZ+zyB=Mn1HHo0Jiynv){&ytfui|x} zIHnkxZee*hKy3|b&o`O&P$aUkwjuSJwyo$6$9J+TN83g z(CP%T(9>}~L=2Q-Y{M;#2;ZDlo}7{|{{Yf--=M{~rmQtgr=E(QhDv$FF_vDkI~F(Y zqzrS)DF)K)3bLxBGMQkKcuJxhMpoRV8}=7IH^(fcuqh|d4oRHUWwTb(RZM~~%2LX8 zF5M4fj)f&dT?AKgWlYqu(!|acj;5(AaT)A7SpBdgB$$p&T&fr-vjnCwyT>Yt0~;N0 zZOzAS__Su9Lfx9WDjH{;MG1}pt9cqi3g7c!xU!$@Z{xDcqdujfqiS&_=-^V();7yf zBDe``YYxETc zcR7zuh+wuxBhP#LVZKSCRMQBknslQw%7b+lbz55qek1Pw4%hyf6w|shP9M*~`mDLq>^)rDEwWnLGa!xH{-L2G~zSx|x zxb_J}paUF_P$e}IR7j+QEA>JD08e3zwb`PJES6Z7XS7SpjOq*q!N1dNbgry+sc5*# z>SvarY6?j*hG1cYUAlPjd`Uk7V-0&HO3f*{gx=enO-?py*c(nR(!!-R+yT&O?l8@J3u?$|Xj)1t z;?nAMI+PBrarBSV5|kXeFdkDvl`vG)N|secXwh5L=J(s}wlaf@rb@O>piNL`jU#8D?Ks(@G% z)Ldc}?4wpero@BOy~YT)L?0}xAp*o6*ji=bLWsg8h}@m9$vXt(hsPe^lYgnK< z5i*4yld-_F60MZme!VcwS_wkI8s+))Xt zvQ4{-Vd$JrVgg>*xbKZV%B`yhXB@>sFMgkV70?qJ6-<{mZx+O)HI7}PA%342id=?^ zp+F#M7P;{fq^G8qKe9{{YS?i7v#{1nS5@!teXvw) zTX82Xc2F1#_rkTX>5X4ZwhLi@m%U8*{U<4r(;(umGBHCSkt$-VhdCJ_G)ao%N zAQe_C>b~CC>XWGGf>y?)T2KS(B%BDZY@6_PWJ3@&ny$6{u%!OAheTG zp$n&Og>7szX`rU!$R~28P50^g;&W>qGH{D+vL_af>*^!?Z`-aY`T}Z9p0;jx%lx8zy)Etr>-F=(bN2qYn9Z)NtT*-L(OIeA~rzGEG`e{6@=*3 zS_I+V^&5JX}LemW3|s=g>z(NbW_x{)dN>8!w6K^Sd(u``5yRQPCQW<@cQ+H{*8fg4}^W2z8+hD-rx(F;;M zrR7#qJvJyhSbGa%mqh;nmV#lcS{WZMul41Uo@@;n8l!u9zgrEkkL))_UT||P=BQ4Q ziRvyQI{hfarM~+Q&IcbuMpo!5cc14!;$;F&F`+NE_S2+}{{Z*JqfzYA{)LreoTcdp!B;MBC9f7tXi8RObSMy+n>FR0$ zL#Ih2baVWrk5FxoLyhd0Wou?~(Pb2>r4EVZRaEtAAnH?bzkRUkt7fV+{5Kp`l*trv z%Jp)ojfM3)5_|sud*b-%fb||4q=(@*2~x`}Yc6RbJJZEIg39_0nY)m_I$s^|jAFjV zXN+eV_Gz80`K0o)$|d=ZV|0^p57=8_jycPdqHga%RqofC22m6U7D$#mjV;%6+#BII zsO)9-?3zlb(miy*%dQb`55r zh9=k?Q`xxAxML^atdBUTqs{57dKxKWV&hZV=*ISKuWNY6p(RkJB-Je*e@`&2qJoW! z7n)L4)LOvxALAZl>@ik}n=fdpYEnV2aS>LARsI`CZSU`Hhsno&9>+^$TmwKVXqsUz z`Em>|i(`pFr)K_(ETWu4 zB2d&Oh}ITYjDpq*MZp&K7&41{3elp6v#qD9=1!KL8(N$la z(!O^yPb`SaLoT%Rf)7$V3!a!~3lONxvr{%)a&^f>MF?`sH~*w9;FOyN&{{BW3p~3TuvxO zzvOt};tJ@q7+QseB;|x*nSs5?8cp`G$0y0NsbaJ)f1hSB=F>@28d6jv6lH{hfQxh^ z?Th^GD?%&_*c=>VnPsu0kk&gaw>-9ONJ;B^?~CK|`mrRR{;&R12C<@3V7ZxrD_{Ch68Y)Y%B)pdr!ml6y0GoY4k8zH6zeUpurOzs; zP{m7_PYhpADV*s40Pao31p(}eOva`}c6eZz-peFtQNK3Z`eP?Rtr=YIuDOQ4m34To zVwxVRZR5E1!?&SQ*%m|bCW^0BHDa|5WJ&y3V?ZI#zGli_P-f*N3VM zbIBvlgPA-vG1w*c7ALO6-q`bJj&byKERbQ9wbEsrnv@BuDD_WG}XAY+={ z(MnHcPHV-L87QM%yqalLg^}5=RE^EYOB>_28)%zI^bdx=w4Fvvm_yH%@~PB|Rl?*U zK25h6^dptk5^!Cgcl;y$wyi9MjHwb}9K?Irsvaqq&6t|@a|u3D_R zmQO}$mno8)M)oAAykq|Wb-wt&j}?0pEZbTP_r{DLz32x5Hzf#U^b)nzIPf?@qQH)n3E?q1(<3maQCdd*dU+ zQWlAfaxRh$h$C@qbCw}7lH}WBeBhvsctQegr1(AX#ve`=_O|D^z-(56d7ws6sA4d! zf`_c(N{y}lmF0j4ZPn0prS^pAvPr6weTo5KqeyKA4%(ifXKCK zQU>@SBPEaAV;C|C3}WDew?T|yq;tBEEw!!J7{rvx>m;c*>^opEA@dam?nk|`J&efS zXyjXV9oS%O0Hv34`W#g=4zSWT!MiZAAL3kf{V|M9CG>%FfAwH91ZY7STMz));XQ>B z83X!ITHSBk6o?rU$GIZ*>xTj)1&m9#``|E>!%$Pw$VeOC6R`^lI<$f|l)c=IqrS%o z_F(D+T8Q-)3K-dx^cWOip&+7-)07xK!Ta0J2&AP|VOB{4E|5q&5%<9C1K_Dvlt-wg z+%lH)jdVIin3?if)XY>xs_MezG4}m`rW))NY&d^0k1to{P&RFwNRrEzw1Q%eTT%<@*loW-hK<(1%MKN;i=NbyM$Tj&mR2W4 zhfpvilLBR|Ggjo)={Gf2MN(Ht^swpQrZi}4HklQC*^?BikC7t-B7f=Uq_f!PXf;x^1u>Gd*89XHvJ8+VU+OG)xcnQ1vEfeSxv()z8!yJI`mUYi3Fb~ zG)oy(Ed!epRBf^E_Bga%lSsqy*8whnO)F*d8cO22S)*$ts(U!|h2yc?JUsBOW0cPH z6*aOj)XEXpPM*Zyzg%)j@ODkI9J7Ux0>Y7(*MXs9;gdBE5GI2!jWAmznMv>B2 z3Zw=BjkOOK>M&MCc0WB8AH6Cnk~o`~RaU}6-`5=ZB(Bjnk)Ylk;tHIrIa-Zj);ouZ zmf}drvoF|>?Szh2-4a<_Vf;;(%R@Oz1^KEfpW;H~Sd?wS2cfr5#wV6-6mo3NL6$r< za{ZAg7mp1BO{f-uM zeui&ES)O-F)R5DfaV!S@kZw?(;9(U10A$qZl2W*-5orD%l5G9H$G#@!uR_iHCi(S= zBc4_gl{~p4exlthJbU5cJ9`=q^ognwYbZ>pA_*Z91k?WjF5MJjuAfEIuEq@Nc`462 z7nCUqB$01(zRG(Y@kpgxGnJK<6wyH=tVQYMy^2&3d!4}4Ha;!3IdWr*dO75VQ_`$HdbhB}tw0h4dCY9Eyv*R8{X1K& z@i&!qLUI@~MyscJ?<$Shg4R;Kg|P=qqDeLaxnz{nEma~kF|Nd;S&_YtEr%mkbmP}% zgE7mhpC>g_taHW~mUeqIM&s3G?0x(F@!uK7eVr1DXsXKSDVCO@-lW3QmE}oLhf14o z^!}DO<;#!s$ux=PqMACC5J-%~U1Th!SX+Lb@L`Tg6KRD|337@=o{`_2bu$?hfEUQ$ zuf7ZV_F}R;%1p{B<*SNHn3&yUV`p#AY)#F285em=Q03xC=@3*Su9c3Y-GB@E8%VW~Rr(0k)ToQ=q+j6Wd(r_0T&%cIx^@ss>j2fBsFrn zpo9X<%Ae}C+jz%1$wpI641%;8AS}@pVWpLAs2h|20BjXLTN1*l>vYEPyT)2n+WUd` z_x8g#%duLrk2kHTpqMNm?gEx!t47#f2@7o>UV&@v+>OpZrsuQqT4JdH+gDt3NTh$V zHf1;4pu@#4V#xzMfS*Vv-cL+3Npvcc=?GXXWS8lUR)ybek_NO_Rk-Vd;;3XyC1UDO zS#R8Lh$Q)Js!EB_0^3|3mNTbmL)_c(RXl)&VwAIM7(2_$sK z6HZfSUDQDvomnc7KZd==JqRUKaY|2>mJ!CPqd>5~QZYvCRNCm3;8~QT*@JcQ`NZYD zj~P<{VDuwMU2v1JztTR~2&}%rkxD0w6=f@XVsEj&I$9-E(_(jKJvw3EL=5x9e z0+{ELFLrcr1|0ymW9Jii(+Zr4BC;tA2FLZo!ZgKgb|D3bH`~}_rSwkUq8LoF4NknK zI~D3b^S|dDU&Yx~bL^TXBo*J-j+kC*$|$rvM`R#efOp44w;d5lsTnzHX{dP0T(gu( ztbk7$8-*%;SMl2(3Uhhf8T1if{vPCQ@x9rwwdnT**xu^BgZ*C_A>-+s-eO$&M(;kxW=6owSS(8miP+K=DYfvZp~} zHD6(m%)k7TBp!7iX1QMZylM2jk{Tz7%?}u%u=q^j3T84&P%_?&E z>Pxb+FrLLsfZx;LTh2IPDav&syb@Ouw=#?7a~e4oVHERJA@!0po7u-pTYPs$3(%Zf zD|nwOYH4PQXyk{G`gz8~NIeKUUjEotq?t%#SFtK8`FWmGn)2xDxrO4LEB^rHqv;#4 z>Mztb`{FrcDzV&B=q8Ilsg8MJNTSx(b<{yB0I?VEjyPL;Cq|Njrh2+Xkh?o5<~Y-# znLz1($=bsm7}y_0PH&aV6&RYI_^@+S+gTy@wbyO-HY3{}oE67p(h`z|m`N-#$1HTx ziwKuzy4;5IU^?TTcAX*kw$E7L_%gm1psM0*+BhPDnj`@vQlnO{qz<}>?~d;tE4d3L zT^KGi_>P=oOI?{X!7Aco6%0|e;z&)lK0gN)$v$sJQMI!Wl~CpRTD3;CvTBkjoEBmY z$UVLAk;iJll|78A&8cVM`U=`fmQ_g}7Un4>%8_M04UPP5g=_W~jd~Y{^V&(PX=&Nn z*{unRo<7$*l6-Z;@l2D0WIqx!#h}Y3hb|P~GYe{YWlKpp=(Zg!dScN^BU4?1Q&h?f z8GNd+!w6Yp2X)wbhLP-c`(jxtU5AU24pp3Gux2y7`GkNW1|5R+>-M%eJ|x)OTG6eO zKBAtU3FSwq<|vKAIRiij>KJt=V~&`?MGT_s&1E^kqT*UrM>9uL{16an()X}t1dE=Z zrVC^7BH}FPlQ<z^j9L&}M|7Ub2je`` zGMY$Zc>>7A(T*VY7j#A+Cx=hc0U`ukw~ zT(ro!Aau!L%d;rzjYC!ZsA>5gmRXRMNK^wS{kHSx#}fQqV^>2 z2e-C57B|?gW$ix@6&8z1j+SCnvG6=%t~RJeC1+G|R%1yax+;Yixo=5R-u}Psdbk5URK}^tWUpT?S_(y zL-Miob<|Mu!@nX6ALAlirO#U)tM@T)0Fl#Q89*BwczFRLXe${nGS(nR;M(8P38 zZoln?N#4YB(E+4o3!(J@ECY+}+}|1RND1n|s&c4gZfw*^P{7z50Na1I9x?rf*ev-x zQbJW`s)pmfIk?bP{_XE{yRpKg=@3=4rDb_hIDJJif)nt z{YE%)$B*zYAGca6 z&18>+E7B^Nl~mGHuo1SCunc-*n=g%yOOy)3G?U{qBk@P}CitzwdBWG`JRwqYxk!>~ z>NXV+N7$36aj+e+=Qv6Xy2%+c%W|)S8HIju=+egx4={l`xND$0{g1K4r<;j>H__}I zKf^TK4k==x4%B8&T>Qgw#fPQ6jmK@V#V;k@BPefX$A|dtvxIXPnujrZ8r0Kq8Era< zCdc}Ixb-}5A=lXF$qRo|>R*O`woLSNsh4qmFt4L^2=f&Vj65*uk4Z`y8O-A1P4O4@ zMEFblMP>5m91EC1!kOfwSrp?{B#+nE82WnkQa$ll<(wToq7RGJ9}j$F{h59u{?E1T zK5LcF7G4+_^J*qCQ%F4O9S^esj+K)hMNFH6gE6^x#E`{d&Z&%o-~F=^`iHq5KG@;% zKNXKOZmjIZ|wEd>gc zKy1-Tx;7ynCqIVjdpcUjm-v-=zXar*MJGC)&P|yQTFDr)Gj+Kau>4ydz8v_xo!u}? zCR|aeZ4za?MV#=2(Nl3meA+^zPG=XWTmHLv^SAlOr3tmBv~f=Ym)b97SHz!&(C4&o z#2E&O&fk{Yn1-SGRl_#x-#{s%f4yV&$6=atXfQ;~dsHBbW!@Q5)Y5n8Ykh zPkr?C9&wnX$t6zU-`fjDvRI=fg}|}vY-*qpr~neyBp$smOiL4JBy2Tzw@f23HOj^# zYuJl}?}CG5Axkj2>ag>MdgupoE|=4!_c!Z|j197l!8>CZd`i;a`dg+Ag%UD=H(ULU zv8*%;BCWQ#`{P-tY-mKF+gJS~8qGqO^)MhC`;0K56vur4YQLNl2_Z1CAm4tL*kMdE zDOxgEosYIN0v^x`gRfAxi*1BfGX;N3Tfa;&1s!eI@ql4VSwgo_(+s;YBtu%A?Qb}G zF*F+X=mF|Tz;rFUCy?^j>ehPr+Y_RmhOCIu-bf}67h(W=T6 zH}va`CSp3Of0vcCG0=DQb;3|6ijHN9Q>hrMbv zz1c^m=lM<<3q+G?qB>dEaxMwK>4v0@K_@kgLWN_EoNcJ}!ZdA`Q1L8s@+tErBAK@m z=(&t|#-Q11^i^ClG*!?;^SNw<^5sScx1Z%dd}m=s+lF%pYx5~SPGt~H9-v)pb#3VV zZ@wdwqg8D5DtzJNl8qLlO385Vqh)d5anrUqxIV+lmk*g#R8g9Xv%(Yu7$dFhaH&%o z^igKezE@D|Q0@F-%~CeFJpn#^ni}QC?(}?x8iiZlrH=JA>ZX$_8Ya7Za;gkxLRsGzntzZe+iGC#Q@bjkWe>O|Fi4 za|&wNrh?3qf+dO8%IB|NSi+py0 z%8z>CpV+`X3SUbs&(&<%ZVx~5~U0uQVz?{*i z{{Znmq2^g{rpLvx{WyLd%-}?XweN4n5tV~%WV_rBj5^>Hb?hEchCvpWxf+QbEs43S zpvEh)9d(U2u-~@W=!;dd5^t3cjA$Em=nb&G#zAIL8ltiF6K}o|%|)FFJ~m4m+!1}p zafZ`YL8eDjBl6i{A*5}FqhJqfk-fgy^L)ICbb1~xE9@GY8P=ot(hX&9$fIDx#wp?D zb5#2i$iks7uSJ!Qq!YEeW6+)YI6ct1LI5`)Z@9#h{gu%Yz=hd>vl}Tk>x{S9x*Rrt z1HKHm&}pNAB?^#Nw_GJOGLsQQY{J_f*gy6&f1xIjg&-DCJYk<&C(N$iXYZwZTdnb< z9auRAMH0eSpa)_B#Z&YKtywEDQ(<9;Bsm)Ct5&aL-vO-+S{PHGd!f>Hwil!R02uZ!a(}Z0eD=VOunQo+!*Pz2k-IH>@$(@dXZWiZaFp@(lAt~m03x`6XY!u&S z_r_@ju#0N8-7vL8`xQZHE(fQ_TsztsFJf zSuRA;dc}s|ci(g49T4c!e$jyVmzsa+tjj6Req7ZQk)eG%SqkpH`}xO#=ga(g{Oi&5 zzl%%B#XlYP&1F2i=xN_P>kF^1-HztX1_~SY?oDu(3b;eX%srqy3f@>^T)C zc}z&QR#tCUl7Bd=NNU*nDH5VFE`~^!!ARe*u|M~~TVu4SpE%4YYH4ALX{Tz46skiG z%c!-(d-uPLQ==vq9MK9jR-DF*9-;&|dnU~T$u%uQ7$Ihbn5cF)HV2_S zw#20>=$`Bby`iPfq;{v07KRRE#>B8@Zh$w7VDhwdMc-tGR?KLlNGZfdBvMedim=|s z_>z?|B&(nvOvyZRP7+C`LoX>V<4x^-v8L=1MeRKVa>E2_WqP?&QwspAa&)L2z!t>^ z?5L88iaAPDnM&#!$}Xl`n_XA9_roN?!`KJUP*7A&mhvj+R+O(d=t#jk6K(e!c);M6 z$|lx{YSxc3$?2nlMKVWG%VRh4_0w_O_Qg`InLU-4^;R1Zw%#mp zIH@hMoK@(}u2-t6uA7?eBtX80Z&Enxzj1EZq;jwWRi*Ck|Dw8MBdo@T17%qk>ESC&#abPeRUj<*8}lNFURP}1g$9+nj|L~bN8 zmA?1>-SI@MNh>wHJtYoPnoC@hQ`A&?l^SLY%FHY+_8q;>8{@GQoJ{NRcMZ!Vh3Xhg z?pnfMMax|E9kEUc2c4X}8bVHs{nxlL|lC1~TC zIYc12)h3dl?mom1&MU=xGMR19aTG|BQ>jsFSO5oJzBj|tLb=-|hN0=Inh_l_D;Z~y zA4>u{F58oWl0`iOywFV=yHdtgiS*jU{q8zp-9Cy@>JcZyskBF#TuYXtZ8Im z${WY`#G4&iSk$>TSdP@u&H!R0h_NjhQ?R+%f;)@^tqfdd8B^r>wDeSUDsvm(~~raKP~sEOsT>*pLUd+jzyTGA&!O zjvgSYpq7@tkt3!Q^TuO_H2xr9z})%0u#B>nsJG(oD$FQzI_hMp6#UAUtC&TkF)l-C zK6>Bthxn4(V0j7%^Xa6j66+C^7uG=Z-)ryJ0#R$GD#(|j$1lzEx-&&hkgHYCE0rN+ z^loi(00cq%zIp+Er1Y`HapjyI*%`Rc(Y>MKEc%&LP4bzQ63SqbzB{Pa1;}2yzo5sb zA3l{Fc|2v>E@*h#j$JD{Nl4#CRuSq$|ZFa;p*psnidU z51e+X#(gq8U+9|1003Q1;2a5mKty#E(a(KK6yEm+#@JZe8i6OvWLWN#+#ZF;Olt!` ztw>JqO$*puxa<01lN1ncC&{c*s@{Piq z5$}G+_*{^VMb!_Ea>ne-)mP^{5myYfm1)V077}VJsDp4rbp#Hh9v)73C2OP5QifGt z&wKb8`)=`$UqDM$wrQ8cFUz$xcIChJp5xyK<%IiUEN(AHx33v|4fyK9P9n)ygfscY zn=qraT8aMvQC~}M=M$HY42sh%rzq*83Goy5A>uWmdhP|ysd%?5RWrb`ND`W^$j2wRGgco71gicHTt+ z92{|G{B|iPt2Q4hc;3x+UzlW^M4-@D1d`(LPqAO~kCXEM00iIK8a-v_yq{KBJe65; z=$RTyeV3Oh*1y-zJjIjB@cy|~#Pk!zmOtxz8<%AeQOIZE+QXH~9MeBeo4O++&M+}zJbPoks#xSydm9S->HaMh!o(r1rM znh8_&f^G=J)RoXJ0zaze{STZo(*qSgv#Y0beef&M^Xtk}hj$B!#{0g>1ok z7BC21yLdP%j0sU8cObWZ_{hVNfVsAke@qz|lq0g6Fkp7yslY}Da0ZZeCkD(Z)gP&L zHn#Y|LknxMBL4tv5RB7%ld%J@P;df2mH|)(<$78M6ih(;B-CwV@kaWM(~D^7kx*$wh$zbNHi83E%)<` zVh3HUY;XNA(J<;=Ei#K-eX!;Us(xFW3y%0p*{EcdT9sD7U%nc&YZ6H`5oXn6Zn#4d zR7=bY=m3uR3$qf@&YD`r?d~vTvkLV^WwU_5;23C9(hDt?_crl^qZd$2q9^r^!|m^d zW&x_44@__B8<{-gAqb#$(d#!Pg%K)=I*nU~7U}xn zXa&a#XBC-kZ|=pX6%a~5n<(;A4(&V;;Yj<#W3%vsJ}BS_H8O{{WmG#}eo01)gCPU%4cAs`+Y%7t+0U zJqYPxg{|1yYKr{EllTITqNvSYZ2F5`dsq(x6^#>dGu4$1MM*C$!vr?gy$J@^#k~u) zqieyn)YRDmv&hkE*vR%ITDFZ+fJM9X# zl}Hk8^i?e{B>Lq?s%b52-%;&iKejyx;o__atg5E05g4V@B;*##Mfoafg(Vnm{o#RMSWy()J|THouH=PAT+B zf@E1;TUIQ!u_TZc)Xf|6+pU#JAl!F7Fuis%6$G=rQH}Q!z z$>=?#a&6EP*AGf4O%P3($6Z@g%~7fXx{(-qm&)zed*H#?$~z#UWjTUN8aFddl^0=a zZ}?A-7wNI%-Ukj3UvuQasD8y0qQZ>Q1)_9ocm zgOis;oSFu#&+`|KI#s5o*H(2SDuQWkOdpnj~2XHuWouU2oJ3a3uLN zo@gdq<|zblEV>9_LAP)G?r&v+-3F**tcP6}i%S4x-qT zI&~B|sN1eP5?oQbTR51>ZOCLh5IUTBx$!AGI$@HPA-2;a zJ@0XFr~2Y}f7d%2Qf*TwR|YU|a5{Tq*uVK4G?TVS&R7osVss0!tZu;ew?Wk5UXam_ zz^I~{12CwaY6+2w5Viq(55^Z8*<6}L%PB5@{Zesh5wXRHe?CWy8niNzSDMzCY&B_K zw3+vN2g3OUV*OB<`AqvG*NuB{(<5y^QeXu1RQn!jg^b0NTX$ z{{YKl3aL6^i-6>q1r?MNstTSyN-e{f8luqhQKU)HlCFj%<&NO5HhM2qoc~j zP3*0ur>GP$Bg$r)F=mzRcgLRjN++P4BKBoCzMeqT%^FL8S20vwcCp9j{{WwkkG1?X z)Ved22019I<5-qSVhTNC%X{37N3Ppn&OQ}3eLoXF1w5}@)v~L6y~-p|UgGDl@DEdp zeV;=plVk4lU0wk5gD5t(RYeSJ!}uj#nsE?P%yt1si}%L((Hhwx zucpr>Re}bInaqfV3tfP@>DS*Dj8a22`T(0erl8f$s6kE>mpV1}@N|vIze{(;qltD3 zVHsXw`}(eI(wHSx4H^g-M`G&Mx2=5Jd@e}P>MXd+YJO&_Ilg2?OhA{ITX}7;KstUp zdZ(!>kT3Lp18aa|!8a_xD;Ec(<-0Fv`WGzm1=b+CIMBNF16)KpdHhPfX^q|%8wMOFQB=p8=9 z-wfcA&hN>13t5ZvHA&%RTYiYlcjxL#o<_21MX=)s#3b7c#3~osTk_GT(8!%o` zRV`YRuf}*aQGld*V>&evuvhEXokG3q@NVH>RHB~fqv@yt^ zHBC~piEXQKtZcfEP!0AzcEp>oxi3QkrEkQGXht3k${#^vQ0ZZ}{I8mZNA2TPiY&YOLOgCRo@t$!Bx9O(WCo$_X_C4}8buW=Rm;t5tC3_I9q-gy_~ni?-It8o zMYI%)SecQju&aSan1#In5)=zqD6!huSxeAUeU)jDu4h3dPGd_L5zJSnmS(Wj#@==Z z?Tr{Gwj{E?iCctfD>D?#X+#-iEE6oEs%5Z+Y(dlAiCc?%;=Gqa^S;KxNyC|)BBu)0 zHB_|KE=@f}J3!Ksr1~}N_OTm(d{uN6D=IRBOH7l>)a<2{r!7-Z0Cyh!e@tM$g_nnt zo-SoOO0mjrrH}$g+pp&oO_6L4rk0)&&v{ptSPdFMYxmo@!4|BjsH{qQwQ5Kus)u{> z*dYBn;692ZT~g;z)5ol*Cdxyil|GU;2hIetQlYqeF8Cfiqc)(bkkceEWpZ=n2np7r zd3L$i0)K1p~=a#f*Ad z{*6M$*dHonFJ-&t;(|0~jB{iqS5djrI{yG%2RbjyL*&hoRo1QsO--X>H`@I$equ6_ zJe5?j!6-;2(GuwrYU^=u*ZiD3awI%aE?SUPWz6y!V_{*a_B{ogz3~44BJ4*SV_<;A zEV49C%Mm52E>FGu8yjFtCXSe-kp3mCc~oX1V>9U*qm@ZVTlVpYEW0Mm5M!CNnu|aa z`C&U7^c&)@E{Sx@zub*V^z#ac<5GZ<%x*o%#6DRvv8Gs2aJ>ZXl@(PoBWfzlqUv9& z?0Vxo%_6EO(d67SS2TucYAI%jYId3SFMLU5aw)|lN5gqdD@!lU!cAa^r8HyI!1cY2 zzZdh0{FJCDx#8@RX|l-ZrifC-GsvwJauOHIxaw_UEIXghIh);!DO01)vz{EORElY7 znkUewnvjqrBWs`ZxAexoL}uF;Jj$hB9Ld%XO+!}6Q(nJTZjSgMQe3F~ZbR0Y^BQ&XH!){aJBPXv)Pf=KGWhFMDNee4e1aXxBJgt}$!cUzq2 zb+A&&9X$+C#d!3@5Fk670ovmCKhpyEv7CtWX=$T)l9VK~S$T}iTS2zvuix9Jj2D+w ziBf%=iaNP#czq(Hf)pm|I(kk0O>gyEr`rZTRN<>D@g|6BGVI2iG<1$)^iMvBu+O@tB;}^t&Lk+`n6l218>F!CP@RyLmNoU0Em-qN-fhAiK>C* zrfZd1oU)yZS%>R|eT4;^-ry3p;;Oql}Vi`XTWzbRl#C5>~%ncc6+EPhl*I~a*c~bD7 zX!LRU5%yo@{AEd$(g zE~~tHg2to1r6>DiwlJS>qlL;3uFs=#U)tY?`0{~rkBOWuNt{4zpD-gD*WSl*=VOJQ zI7`reNko@C{g{3od|=9?m*MXe!vioRWjUGVB9qu3t$!ff5{3tj@_@3Oaw>hFBz$N6 zjCjZ4O7WV%D>8+1z50@ILk&lggi#$DQGwunhB4nBp&R1zbp*p^e)_>8#AP*ln$Mez^z9r#)C%7ycvhk2Ad zH-p3SKvSNE;wHaw25qw4-YmH`Z(-K;Y(?rS5RXIPMdGn zp~q^AU7YV)BM3DUdkh){ghon>Y5d?c0ECw9qyVIg2Df}CM!GkgYrs_W92=7HHbXT< zeqB=<$63s?H9WxCuW#kmx3)TCj>);v=FAyoC6`*?sNWJ9614C$h1aItZ_@=1$2cQp zH&fJ(*bD<_iHZU`j|O#fiATY+*@Je^c*;V9zeQZSjIAW@qWt;S5T30yKa%ZDEWn9HQ-DI(In09M@rM z*n8s`ipr;8bl{^AFap*mW3{lx6&amKB=5b6!AQb6vjNu)et`NOzNSzBC$Kn11Uh7O zn3AJN>IZC3*uu#wMt_EHe%8aI5v=66ExGV9sKnx9&H;wU0izSlT~}H)ueHZffkqgA zj8^*-vBs(pB9b!o20cLfuc)1mz75%ngG|dCO2s5lY)Ll1i(t84j6NEMBn1)b+y=QH zoGFWndVIcmQ%#vjBMoge2&IZ`)C>9dz+pq8sm^#3dFHR6YU*i_FVDtFj$|8+WNo$f z)wsF0d`3}Ev5!jNz9)*0B#OS0xvO%?hLutEQOo}T-raxDdl9zyj|FB4uFqu5S^x~O zG=oV(0)RDM-+TA(izq4+*%ugbl!ekrY8IMUKo`G_j-Y-20Ja%H8MbG#kBm@N)U6Pp zS()2GssqxjNV5g+=Nf92BPV^Hufa>5@l8zzTlsiZ4U4I&3~^$D@xA6PeD>bAny(e!fmSD@5$D zhHPpLhN}h}VrC>mj1)>5>x?lR&@9M77Z&Jok&*H@?Nj?Lo*|;C;vN>KD_IyaR8U1= zChlDa`n|j3i#{!KU6xWl6U`c_fX-NT~zAMOTcndO?8C_;#oXU5Jfk{R7A-Z_m92q0QiP23K zVke-HxpE5Tf8soyBm;f^#~gBIuo;p{*;eEDfPj}41pYA@&9NJ@&N>#Mp*ojKv)C~< z3f=zz?Tr>>j+Zei3#=TvskG^hr6mq}K^8aO*X(h8a9+Z!xunlm zB%^s?hWx}aG|K03{*&NiWQ{U_gF6ys%!x??GmDZzEqm^5d?J-CjV_oy4E)o~k~PsM zMTr15UZ%$e<1a@tPq29B4nnO!Mp-TykPSfg2OHzJq1>2VUVQ9UoItUdm=N$aijMnt zIO~o*3hkD3S=}~yO(bmzq^K$+S)?FoAn$$mzBdg9Gielgjc7`mY0DRmCMf$|boL5+ z3--q&xIGeX*@w(!=HaZWppa9nZ4%teA-&l3 zKEtO>N>X*AQY_yzX=@};{)eSQ9arhs5y#3>rcw;*iiVoBRmkZKOnGstw$>YO-yM-u zQpC*aes-Qj6UOt6w$yCCF>gi%rOIRTWK2tPPdRRFMMQ z)@Ds7wau&sIuebOjr`F%NTN)Z%>E zrv%l6L<6<7>H~A_i8R@hr9{was|9&o_BO~!7erwCvhU6MgZ;7;BAhG&s51x zUqj?*W4w&TM{+;g6U#WIWpLwc3ck7*fXfW=yAVuaTza)cv zf0rATCUWp`k0zMeo1GqmF-P*hRy5zFJRDxfz1cwmzz(=bsuLuvVlv1_QQqDD_@t#` zDBom@>1z$Z8yr*6wX&Zz%cQNUiM9U#4Np%u#C|1rXICmg(b6hHsBL9k?TF=EzNK+C zzQmOD;wEu>>N>A`q+n9q1R z3asXuzL2#gZ#7<7V%V~dp^trrK2BaXTz+b)I8ihJd$P5A4k&mmR z;^y0DUADI8-@Y+RX%6s7xEqm$nDLd8M8RX&Tn`vnLQ{_@>~Zc%@>G2KNdl-PZ)=h-g_S}D zl<%X?xbrwlN{TsQ)Ma-uBRd@-t-js5^*H>m^VuagRDPHEOluxKUe7$L;|eWHPb}>Y zkk<(JTVH?0#y%$6^nE&wi^dn@tMvoo02jKw)3pw-IK0#;aXkco3gbt~!$0`uo?b~a9xXJIa{{Z7aS%(w0Y_)3)^$yGo zQx}TbYKhC|$*!uL3KsT+eQo~}5ma=K=TBCo1Ist7k4jfuZcIOdd7Vc^S5(=>Xl)q+V+ z8ICX{StGdRfu`jB@l^!Cqhdi)xjeaYysnhe$gMoRYz6MNA8>Z^FwQ8Y1n2WTCT&Xf zvP~*I3afy3KB7UmJ;kvX59~as6(|;gV5>!WVR@C>Hv|m_>A3duhfqR2mz9rK6sbgK z^NNrV`E;7w&{u}VC@b+IkCo#}Ia(K;z zjBWVZ_~~CroYHpmceLzT-*0e3_@JNWPg#YrfV!{8vBMl2|F;~wmTIv(MVBI4FImENli5ID@3kGs&3mK zz4~EX(ln;JW@No(M5b4n^aHiX1djLr0KOSzL|adwY}$?qDx$qp&m6}804`NS{g01h zhvoVmX%!WDbXj&|RZRhDMS&c~BTsu=9~f6B=%iR8q)}!s9ZgUWt67mZEw?~?{qfB- z+139565lG%>T;U;${ej#hG!6_CS~-Zf2-~=i6psuIb`2LW;8~QQ3DvNzFF+AxDE%t zIPy!82P!A6q-RBzjNR1g0IjrJZSat6ik9|IT3uv}I>jM^IN~-RPkV3N_r=q`&X&~< z&ZSzZps`J4v2+RmLtr-ZiA$HGo3Y6pwG9MtYIP#oY(OX9?TqAf#zwa!S*xgp6x6|K zC}vruc1^<@fqQn_w|sO(=t)aqj?G0DVvk4--9qa(k4fq^boau_VRO-4Q*! zo<(AYAQUCL0y>kvIDT2D&^f9p^FADkCWcCSc;V)$R)#q)ZoLTy`(v^bwX$wXS|!YR zX_vbpv6wz&`iyizyIO=>B7yXi*jqTX_nOH z5YtiAQ&2$;T!o5;mghzGTOIB^`{5$#QAHzS^%K@*#;Hg%pwk4ZJzx7zVtZqnSsHYU zq^Ny+Ox1N-l~m>@g*iku^IlDC%N@X-!m76@pWx zQ9h|UYq0D_2fMQTnnjCdbJQB3t;kxrG=*KjA5$OGY&xAfB(l4rk2cPsmpK%$yi=q~ zw5=ni(rLN%A0&CjT-|8sQrapgYHH@p=?+-3!!nXTi4f7f!LauK064xZl8>^J<09t1 zin@d5qG+KnO29FNNdwb+1O9R8L(ZIi98$pza247z0gIX=i;tOBVZkz%8#=N&2X+(^niUWsA>EoIfU zux`5wTuykEe}(}hi;>&(!dhe6WhWD5an$9~za?5kA=HhH#vzk>MI)zXKO@R&Xz9&m zHGNcaNXJ@p2~c}ke%OyGB}J`2MS|Dy8}4fPyMd>suelh?P3UH#(Wj)yWu6uJnHotn z+^kZ*pVs*5k6R#@8CYWFu|Z}?B@Cn+>nCy3z7@eTlAV`%PY`AqJycUtOEomBy2%?5 zLBEi1i8wUD2A^lT@E7f&#oQu^OPvU_?5z43Dm_d`-@oJ>2}b=IPM(?QPba_++9d#} zr~d%b8RXlSr?g7!e4+HV1XSVCS0?*Mko-;m0P1ySnQSuVTrWL85M|(NSu*cTw)cpe zAHl~=e3rE`ZxWW#^PX$K99h71KQG9VPFrefXF`q#{?_00I2k98BK-v^N268n{{Z7o zcfuK*PfJ}Ms`WDbP)*#7{G zMo^5m9Wfhg*moX&$bSz$GUd`{oDo+?1kwWk03%R!LdU|t)Q9!JQl37UwJy(%z9|05 zxz7P+O-)x#Q5qUKrxe3!9lr(zpi40Nn~qFqGN0m$^4g1tGMMV&U_l{tJ&%xa$(!-maxPF?GV-#m9$mzlK2=@D z5Ypt5ycAVhLak~40FvaJi}zlZKIhvWEc|KWd|BU%DwJ+rmfS(`Ux_j}x$)AjV+FNq zqHSN0JL8gf4$;!L(TAFzYFUhPK`c@OVv?y=AFdOeSne%sBwpS<@BsEUnNkC;Qfvjs zzBAdXfU0VYwG2a&r0y^{ghYt5Urn&oV5sQJ*xS|Qbi){XxY3TsNa>wR44)! z6!S-}!@~o$&LJ*OqgdSE{{T&{YZhUZ=2=!>TQL4HibE1Q{{S+&094=3#9Z47qb|VY zhtW+@Uq)riDr1@Hr3oq{+>pfRDi8Ae;+I{4G~S9C_#&>iK9O?;ovG(gB1&elSr0%* zefxF8$9)C5?D|jOKkR*&*2hg-TTIy%G>RO}P`91G_D9?9*y)BRFXSVdKHK6W%u*F2-abG^NVvD*w$#*SG`^eATxF!UmjTvGJkae&bF9ZgVuAda{O zvdRg;?})TeHa57xXd~3@a1CUD?QCJu9Po)nkE`#1W{;FVY46!yE-Henh`4T<6Ef0d zsiRf0)LZ$$w$J_X&pZ*5eevhcG^lmad&Bcj zM>cC#64A#D`>`INR>jA*G#}NOJ(!qgsHKF}K_kEr^AbqK^#W~c^tHU=xb(JBvd=fo zXW~4SGisWOii(Ovf0)|_XCY4JAZvz|?R7+vd zYm`S%G*+0B1EU4y+hb$zj&{XOgJv0pr%HE8E-}q)SjGz0ji%JoXKyY?gMVM00k|dPPDrQM=@q!AIeYd^9x0~;Y z#VHM1*-1YWv{GFXVKDSOvaN>4sKIF>DmEKIn$|pZ0x7x6QjC&DcV4%+@O|+PC|44y zN(t%fDk`en%7!vk6xo3zzp%C@@z@+}IkPIv+KFeS<;|R zRg9aK9Se|YR6B)Wigf)ax4Fe4o!B2mRc{zIJzDb}5Gf%6JMJuP z_r}PZ5>jatQsywnP_GjWclF%g@sByd@}rxSgQ+vRNn6rDnGTb4Wgzqb;hbpWQMcjq&&IKT#(9)mX5Jgn;pbpfJVoD+he8p(u83Y2j#qSa%3sP)HL~&b?F+4sN>~x z7@b9W*qm%QWgMFW^Cg!b@hk$W0_0ix79$?ZjUH2!zvPb42^~~g*7Jr)li1B~s>;8f zn1mg(qDdr6qtY$gt~#610v&(GSoEH!*KM!ZesH!`^i0xn<86YAbUkqi{=ti#@1h!h zW3v_jM{B52zvl^#PUyB(3jV^wdM~|>JMTvW(CE#WbPI)Cw9q+piKNoDu)Vj{j%Nn* zw$7=xqKM~!yP;VMD)j(f_`Q-!(B>mq17YL784{Bm9O$tDO|5?C0!D)?bBCxocod<; zjOwiM?on^K7~t}rRI3k1tKd9X+`etF%4nJw3g=nU0en6MP)=Q(Qg+>RO6I^=2H$c| zL5ogJ8VcAQv^gZ3AEaZ?#@m~-woPy!B;2ENRROTOn-9tDj-0aL8zJLIoTw%hJiSab z1GdKawkh&J%ML6d39;MiAEqgiFmc#1N>O_K7#aWmy3>1^lPdc_&Pxw>`#w;d)X(z`S@YypjuFVS!}FGztnfZ$Nu$Z zo-{4@6V;Wf!G@Li^wwoxuMMX-i=0)aeh&m7#$RB@v6^79%=9u`G5Q6Sr(0A>?Qe2^FJiBc2HXwCfD80#qLQy4du>xEq-Uago*2I@L5F zBYI#cI@nul?}XwWR*0!;5{n{+29}~|qN!0(QCD2752Y<_m2G3>;B*McyUpHu+=X*_ zqm^hXr6ed&3_|)rzw(i5d*NFJhRv3Wh~YKE<>;v?S4go|n#a;N++WTV47B0u>9bf8 zdWRgi;czLzvTSdt{x-LEa+IO;oCb|&9}ipNU98CxxK-0$SGG_DF2su7l0Awq~1mc_%{gF?vZ&g{hw~F-_6HM|URotw zSO$3*PCCk~l?uaGM$8o-UWN+FNFV9FwjGWoS}V&$byKp%4RPhkF?|lDY|XaJE#To} zDj?@ZZb{cJsHn{zbIzTD5g*o64fpBz{NcVqd6yg-@wQc*yev;DH7u+)RA;d#-+VHc zEsH6%g?ZYSI+ri1SXv15vbKU59@o10)o=(n<@q1TbHZCJGMQtit)DfRlt`iZXywv1 zJFzzV+a8ZS9bBmycxY;~Y|Rfbgiw$HBmg$)`NtIUJ27zn6E%jf^>o-=w`k5x7ygB%%plT%W(tY=*CB!+6=AJ39B9H!vZDIX4{NZIHQ=W=f&gyDaOcDVcFLDQM z!Qb3=#JQuLO|ru+%;~Fh`bI7DGf5-6$2IM++kW0~s&30gyDqX!(j468F;@{gBtlZR zvGkjD?_hrTvYR_2J|VeYSq*MiGgDOP<`D}zfIT+3HaM(jdKu4?uo{Z_>MHpQC}>5) zR4d)v+YLP;k$W#P`iZIX>FME>`87d`oh-p*P1JxpA3uC^c2!SwYVumuZWWGm5k-B(Ut%a(Ek7~pg&w!jVmSmkVQjP9G$3g=w>t3NFCKKUNRF+$n9&KEOK33T|4T7Ka*fBmaNK9726)Pzuj-oY>l_K*5e9bY3>tkyWZ`}2^ zD)QOTrD#YqC@WEOym8u=ow3R%t3Z1%N zr=QLsmh35z@dj5uRhP3inFNvzA~CFKJE=Z8Z{r$qy_3kVWE8oy6qHpmN;!PxEDtOw zUfsKGh%FrHR>HdsuE;NZ1)?22?F@&Z%14gwp8O*5=d6mB<-$+HGM_TLqGTp!hr;+h7}GKt_} zB1S=)5i3nA-F)3`k4q1kn;N#x31e14^6^JU1zc0Q#UxtE+<9* zq8Y<3qjEzWDvgerpfD;BLfdRV3MS<2XF9%@Q$tc%f1*wQ08W@zSxWRqyhoYCeQ;|x z+^NFz;yQ(fQ}JlQao7n{9=87B9cx^N5AENwRZ#jOQnx2 z_?N=)Gq4Nu!3EdcII|0V@OUTDH_Z_7H|&eR{{R&zn!kWJl9I7p5;FYBgMqh2kZwOX z&zygex$-`1LPB>-F{8^@~%rc%M%Y&!N z=9KE*hE)8MQj@Wq_4yd!f1h zxD&(2Xb_dNGM@|hny8aalucQn-Gl@dLF9r#{+L>*mMN>aTQ{LU@iY~1i<@eJt=Gr| zVGLEv35eMB9e3XtBS~G!8+&5`oz75%^gcV|3O7>Q>iZ8EWMNA!w;-PO>T!%Fuxvos zVN4;JM^@{A%qmrBm2_+eTld14E1pV%Znwcm79$ng)Bzo@hoD)|l#%V}QaWG00LV#n zMJ?5XU#Z40_ROpT>Ib&i#v^H(TYz@kV~k*@6y;!nKb3T=e|lS&4@_ zs`16Bfz%-Djb;e{0Mfa&Syx921;7@Cx&=qT#BNPnk|k|x;d47(=E=Zr5uGA^TB(Nnmw?k(64I7(OKKt!%n4-Zc=?d6ZPw=ZftC>w!UscGx z*eO*%)Z)v;n(Q2x?DTqnhZ%h}IxHM3Q!M7!mRi6F>(bu%67l2@nlaNlULVXjGdcbE znKMyk!VX1b4O6LsHY+0Erjh~uam$y*nv0VfIilSo>o3`tFUYfsitN&}Es3+UXIUpf zc#lU4I$uz^KI0AIMxMcu+4Su-NESVBk8#x;PRm+an+>|+Npc4g)|RLN*4P0>gf$w@ z$9rK|;m}R6JxIVYV^24}B+8a_^ZVd42FBrr6vC2kj8$|SWC$SboBDf3$qrIMGL*o_6HPr%WN7cJtzz=B zu8^pv4rV%b);0KUALC-B@1L`NH#}sOgnD$rzk3wRNT1k*GTA5bid=fk3suB9x zX0%-7)KSz^>aISrhTOHe>CmryQm7GRqan+xl_H9sngZWcvqZ&{ZLe;i^tLP7GiuEB zSHqJfPNn6O>Lq`bw-(>Wx#@}VY_BCi)t?Ncq zn&gp6mnzzqpeNrCLEuOGzvM&3`;w(vSry($jqamsSdEE3HpFD8P6!8xxo;?Fa_K1< zQ%@~Y+n%JGZhYc%Us2JCnVKlZRNF*sT>goFj-L*CVYn#nD+vCfj~aI^h~3(T=UkYo1Nnq$+Nx zMa{jjdQ5H>f!-X!WM>f(ea@kXPa1B-_=sSws1vM47L1;Smt%~vDJl;dEok!$&Kjw7 zMK>xFy0IqYZ*h+|KZcRbT$#3_;yG%BH%R4hp}k_n4)zDGIpKkqSWCEbHMlsvtFCs|7!(NwX6f8xMcJIhJly zaXT^i^^VYSlH^%P+qNo%>MaZ>)_W6+UXFAJSEZD*t1_L40~|SJTQ3gL7GFeZUU9BQ zM}0~h+$P^h_QyUM-JQ9fkYf$a>_Hs|Q;wz4#>px4qXb=wi|NJTwZs=&31+Y*w+F8F z#52c&v}`)D8+m4WZ8uB3nswfx@R&}NuUV8ZS?LjcJyZKj%kc>xeKb>06O7p0>Dn&^}``( zm5qq8u?Gy@A)fR>P|ix|0JAW*u7lqT*e{7G1(m@607x6`94=k3)5cg7UKs~!+(X?|-**dw51Ldqi9kFY)PAhg4TWyGJ9EPh>qW z*9r_9DsF-8ybD zUK$cIrb92Shp3Bn+Z;Ku+>zHDjm4rN2%0xX0mB2a{{T356x9iiTrNbkj-V=uH8P7Z zw%5fY^)r)`u)x~DE7*>h(`}~NSTC|>X{Vy6;|l21gsG{gj#8rg+TibxpU3fH^P2Y2 z?`D55fTj8g%;jXK<^?h>!jPRvzd?^z%Es0gA8hhGZ2YpRS45CX@QzdJk&|sr-wEJK zOCJ_5nA6Q`*^%PZ{{ZZgyv8|^oGOM}mD>LRk7JLD{L;LP`>(>|_+iO=Gl-F^jSZ#d zZEYWo_P3mTrKq1`l@>;Iv5#DO)r%P0eL#2nZ;A4;uEqeR0kBK^*a3FLKXpE|xT9X30oJ)Cf^dThy8Xsu@q?4;cE7Ck-s;ac5-{RP#W>I7exSn6Sn zDyoSKv>7U)8zYAo8J9JONwS5Oz8(dypkrLFqmTWnEGAHRwUIR_F}r^_|8t>QstVga!Jx4tPY6V;nKH>1q58EPb! zOun|3NNK-_q@e_natDpDt=cQz$unHu8VtsP-bJXHBDhG}`i+RV9zU)ik-2&X$SWDE zvnpC@2wYWYyUfH}d$8-V-}+%2p;Y*qI#`V!Pg4@p$k81y^3n?ltit1S?SFhJ9z|ae z@l4!DO3}>Pr!@%}KrB`z2TG3v?}D07Zhk_htG z;@r^bp#;8N11;KFg@&#ACf}*UV}|(*<*G5sIG)nn4OeAEqe_|xC5p+uV*Zkuq^v46Vk&3N;%?G)Kk=2LOKs?V^y%# z8Z477n}%~k&!v(|8l*I}VLp(oHa>0|#@^WLgp!LvPRR30T4bg9_^Y0}r6c6kB+>Gv zMqf(3k5nKH$4>a*kJ?1#8z&zmw3$2=^4b*t0E?-Oe!X@gH2(nUvDGA^X}?2hqkN)< zDyApqCrK(=g?dDqtsbI#kV(I{OhQ#w2rDXvX(Y3eQp-%TJ1lZ8>us)2`{5L9SBG{v zzD5aLM>JB_NT*ax$5Wg7NU*s4Vv04P{yhs(K~a}T)is`muq_UqP7V4I+w5@+jEjXk zB$8Tc8c_9&tVq)tkm|CHxAAM@F_#x&N={`i1eMjk%ffEbU~3)3FxY*!#B)H2RKHF>ShF6uWs1t z=dF;M0KRtfG@Bhm#gBYNG}+G399cS%SyDui$IVr^QWV_#_cq3o zKu|8Se7cIb3ZWaM^y~is+YI0(tVcn)w|rU=i|Fc%D0W*<4qKRK)UQlmUnyzsKnGAa z2mAhUM+z$XpspCnoiiFrX=9lqoqchmSXs6f_ckDSwjm|TH2};3VNe!a~W6*CtKUw5R`UFN%FG$CgM1oAgk36E#i&i zy0)r3&y^;)5W+7DG2MTZk<#|UTNZA#L~5g#EnY^o)ER_wZJ-T^`+e~?ofB5k zq{%BI8B~<x!63oSD(qVpxLg07CHG>zU!{{V!F&O#XMeRl0@ z;;HCW9e}27M-ye4Q`B>!dxq3>sbvSJewG+VYaX zAr#FSO*)PCvA*mHw)pk2`JUM?fV(u)3eS`(zcsq@O91BGz{h+%%u>_rgz&Ui%Oage zo1`tl0Q5fi^r0m!*~;T2!$fG%#>ICd>g|M_6WS=UIFRT-*I4)Ij&}+Qmo0_}7^r0i z$9w*8R)!z)%$jevz8+GrD3&x*ffbL}+ut1WEqW%NWNR~k>$$i2!ARCikZ~?$!xf^l zEU%h|P}frogb+t_?TQ%p{sH~A_@5=G`7S4-hlsM!G`}%HC4IrY{qZ>~12=Hcd<*#O zhD@@lxFbB6T&z}DiytwcN&HyibjFOR`Oo8j!m7`PTum-dT`FcY;TCFq&o4JtM%)rF zbvNv8J@I6Rb42UN9u9vX#kPyFO&&Ik<=6PH+38jyPt!hwA~-8ROL)w(gD5hS%7gvDJzRtsL^u znMW06IqYnZRYNd;syDa)0EDL&amyEIRZS7*Uk`YDH4MgyXSqMna4gEXX1qMI~?K9PQ!hB@;>8M`{XeAzJcbq5wN3bVnOaO|0UZr-Wr zBQnIq?RzNO5|4$7E9hT0my%!1+vGf1mgbADhPo-O)f9lh^xSnAoUu+XVl1(1MXgR^ z^$MVqZ#^)nG(FfkoExsnZQpbM0Bjb$i_c)Q(Lp@IT?RP?ipYmckI2NDy%bXgf{IMJ zY0M#N;()P8Y8Z=Z9-s)@^%xuw_GNh6g*b1BX{2hbq4LVPcIU#1!F}$yM~h=Dl&JCA zpMuiVRm&bxSq@;)kXcx0ARdDQ;s-LHiGC60nI$2XS}KKLchb7o@ow0RpySa+GZh9@ z@=PJPM!)k7{{T!*n;($s-X5DTvq&|6)CI8i(5ww1vOAmH3;r;?MNEt3+tR|r!Sjtw zqGP^UpK!ycTxwy^^8=WGz0Y0FHx^3H`CW( zmOsNkd-cF}W=?8jun|N->0^c1x;Q+J`c-u>+QWb8hf#7sZjBC4!F)lR#AlB#c&Uot zpHew-+s^y{08Cam_>*%z4L5n7UA^H2>RN$#Wbz9S4!Ob%w+n}wE! zI;yx)bO2>AX}Ms+*GQnDL5fw4Uf0*5ukFM|ZZ zIV93rBu7BZ#1|F-AM^Lefa3go$6fMPeThq$i)`EY$Fo+fA!eZ}vMKrJb&uWirg z0$Tz_#VudHBgTqRVGT$<_rf${#tMQsCK zUhBhr%6heEsuWlUQ*kKoZq_3nTqOOOt0}WA*!;}(F)1%FKA6pfgzkRg_x`x6X^m!= zhN`6EjF9E>AD5C4XQx;76WNpuN>EZ6%FL{>R7A6@Nh0Z84hb7DxVPh`B^5}Y@hYnG z4oqcckeK}=mi>>lyknkAb`O^HO*UZf1ky|mM63Y>3$O#d@R4mWa|K$_K^b_@DI{bL zoWNPbA06$v!EaR!Fug*0qO&V~WL=gV{A*H7jOt#7E4;RT)FM zBoaTE`NBp0hP{(yw6yj0jPz+8JuN5~vyxej`yUweV=Gi$OGb&`l~N;81(dbGC#PT6 z9dJo4fsdw*s^$YkYpCkbr?=m>DB_r;tQ}fK<&ajyAU8jMY)+`wahL?w$i_gyhk@G| zrHLJDxJZ>5RSoVAFgY?rty*fWZyHnuAM%`CN%!BT5?V8M14~x#JiOUS)JZ_2NKyW9 zRWS0Qxt4Tt>$GsST-NlWgX{MD;AmS5%kzqS>3NaT)zPp}L{)K*N$g>kXrE+AE34YIb^F1g}kdx1A!dl88|R$HBbx5AnbQdFL0LcIwF z=k&(-NjU|7=s`zIJaN}ara)AG2}>%U2et#jY+FEU@ctO$awjguu4H8-k#3g3c&H79 zuL(RLBh<#jO|PeKw)ljw*ev=WT<@~4QIF`WQrY+$eEJ9ZIF_(f3#7yaByFo6Lx&uW zU$fN5nL{52f}@jAH@UXh?vByJDbWFzIb~#0b%DC~0}tquI&)>ya(#zvdHGAhY-%GG zVomSo3x+BuMrP>}p$E9S@9mDdv~!P%%QcP9`cI$!F(*DQhfuJAxfVMSVh$}Yv^Fe$ zvLP}klTS^y(m%dDyfILlJq+@19Ux;0{QPwqM>CdV)!xM4t{q0Qaw79fP`LxI+Xd|cI${y6j*-)A4w%t&ER~P3UZ%hc4;X36^i4qM*Gq0iu=wI? z^ell+mhKOnSBgY#-3^*k8d)^Ef2EGc?~Pg+OH?)L3??ANC}IJ*>P|V@*zpT`h32GW z?nS@@puoM2M25_Kd!G1u1JTK376ba@P*Y?1mMR60W9|O{Y(`SDsnR+_rA^l74H8My zc1B-O7a*SAFN?h)NM)3lMZK7x*V`U^rrf$aDMl7a7onEtVl9Vh{{SKpmB*o~%MRmZ z>(dOHU6rd^K@qT!8xwCM1-^PhwLEItGF(F$rsDj)y(+U($Rr`G$`^1)oP7Rx!Fg*h zN7Q(Z67ZfUv#aapN}5-Rsy&#(M7PXb@^UW{cuRQV$aE7@vm9_%TiP<~y%(#_}3VULe_ZJ${+MSL7p znr2j$a?;YHxzdZwwUvqbMYrs6bon6`i%hsz<@6F}S*0{nNZ-MxrilujSM@pe7&k_u zL6{-_B((DSY;}j*uW&Jv32P-hH2HK{g+t84{{XhaKk|-<0P%5$>{jT?#h+;AO%v5g zFjC}lZUXl^59@z{K}+Al2x$3F60aO z-x7~Sqm@@hJ$+ft=cT+YODs|AYbA=6+g9DNl#q&7vDLK{@=skVf~cBEvs`MhyI&mH zB|=T#MT*GPIb@AI>}ec@gefA{9gpdO%ttCCmY|5?a^N`~cT zW|ERBjJjW#1~*e>1dW(Kw`*fX@zW@!NcS!m;8xEbzPi4oFAmW%wN$PJoM;T7c_i&@ zbU||TQuSpA#4m`I9BY{nuyQi!kke9AY18~6u-j{N2k*jNH>+;zcL zj(I!ism$`4i8z|Q>uOS-6B|5!i#1N*0T=?;J$!>Evscu_vpd8ABic3`9h+ zQ#Dg0k^qtD7h>S_`~9%4b)qWSSxX$8Lsv~lJH*9NTuKlrVYSD(0NZ?14m);LMU&>V z)X>LMS6=gf8SfMtKwuPUU%&t#&J)O&=;oJaR6v zWhMS~2PTq97gg9Byp|n+9-ni3bIUUAAr$!_WQ#J&a|EZ%a@v zFLTu6ou@Tul$musO%--YQAb@(G-g&;rmO@It~vsv&iG&Asgrf=rD<`B_GJIbpPMt|Y$t8uo+ZI1ik#x=4@vZsa~ zhD_30Uzw6z%PuU3PS;XFzw{XQyk8MzR@q8yxSNNv+M2m48D}!e<=FF$iM{syap*6{ z!FwYA06|YhMAXYiG;Z;$D-CaU1YX|u7sBQIdaVx^UW_Ley;ly=W~2WApv`Ehr$!1B zsniEso`f8Ef8xAO&X~y%(8x2WXzC!2MTJoW(@7_zFRkHv8D@c(F^~|!-%x3c8{hD6h{-8D~2xS zQ&eU$yztajthO-8t=tV>o0EHNFw~Oh7HYrs1soZKbVeysGOZkPHOXe$&H1r5_P~nK zRO|w>NZOXBTBTqjKzW)$Z~@bM^|!FZq}z2xJrXSrn#7)GY1&AGCZ#uJU9Z1w?TJ3< zZs#9cVK96&WoAjU_y~!a$oA0Q&8{mi}>~zQV=+TUQw;@cRwXKBys_z|tP_K*fv6S$8~7bMVdDi`Ef|>$`-d}%cFU$2i&Vo= z{1`%#0%>avL3UGbY-XauN*U^|=I_*ESa zk+%N;)t@tv#FUhbl2oHJdMv6z8a>_;v zk}Z4c>0@ho#N(|Lj4hOO{6#$U(G)8zu@Y8BL2#p~BdG)59Z_G=RFXFt4rNj+3g1s6uv5nPB*gcszeMa0a}|_;Jnt zLXQ2CbC0lG(=STNYRyDT9;RjuNV=F7Hy2~t-+XoA{EX9E(7#5=YLYytnsP~v4v^=$ zwej_SCz%Y3ZjL;#RyI7w6J^$;!5H-}68 z?l7PGD;J_9&4;Mmk8Zo*Is->NX_W&WowmauY?3;a2XUt3sT*Ll9zjvdX4rxc)ue22 zj4DLI#-%WhQ{Lf$Hy8o5PW(liiFLh9m8C!cOysq_iNR8>2-S_3G@#5#`KX$jt*#8J zbPcq8LaBj3!(z20 z`UcO1_@m%>HImfuMM-f{F;^2M#3(!Pcj(Q9G zbr^Za7EaDte2{u&zESbIR4SQ{U#R^$>Du3&Cmb^Id4Cpl!z)W@-Q+(LIDa}(8rJeA zVpJtU^6q`RAI3R;47j#unmHcJ?9YTUyv`JwT1siIyGs|>Z)O|feC5=U(ZV#i0K<_> zMWJ%s(x#n9(-leQC)<7h0InwG5|N7yTHM~A$t5fmsyAkWLXY`Y+xp--Xx_<(5JJj1 z%PlK-l?Vg!HpF=Ev4Z2AOBgERLDh7d;JDJWSm63E(4LHMfVPYSHeE$gJ4k8OWWDaU zR{oe99{mnsRZhRcu420mRYHjp-_YT>p&Mw<)$poKJd)MrbeWPn>beaKqrks!&K1Ev zhK%gX@jt`vAFogwFU)9y_OOELT$UO4@;Iev<@_+y_pFvUW%=zdu-I5s$L2ppI! z-wt?^nSePhR{cF7fvZhl~?hT5C8*PK}q!%p&(fldmdi!a~oc0zBk5%7IU zDTyq)Eoi;0aq)^()ZC6eMT=0HyKw#dz5nOGVyaOHY?mh@p)miEIL*fG_Wh z#wieT3k)`~IJaQC?B%_OL*DnsqHc%VQP_Qs2N2m11&P!;^tWtLQtU*j*vIrKCu<7} zo$rNo#xvq4JZC`tk_Inv*!aRmD$9B{kW}4<$8D@UVcctIAID|gHfPQWcW9~}kKQt{R>gZryR6KFvqSU$vL)t~igM#vCt5zrA7ws_0`-1mJ%%kM(&S z@#p8mtBH8K(eP$wvE`DPq*(6(<$*Gg7p>F|?boh6N}91|nnqS0Avs=iNl^6AxzBhIsqCJkIZTt4>% zJLpNOTBt5K8%Xuv2vAbVj}HrUP$E3)c}d1^|@Pfry?l`OJ`(!{9T z0n+33$2_3ZB=l+WE+CS!B{fWArinF28k3~3+gQI=^L#DwDG6*U3h3+SeNs(MW?pQ18{p|(1u9IvZ`0GsW_59mY!%L z4^_+3EHP4MIejYRZOOpvS3r%bDIETCIg zOj22*wj-9x3Jx|1t0hEVFl3nDN1!U)_{8JnMnkD0>TL3#FQtm2wH_F!PGY)^#`|Hu zWXf|zZATi?sHlvjWg|f%s=eHv+k4*lo=mmqNlha;7Z%kli3Dr}f;0R!QryF;{YK>5 z95eD7=@D}e%lNUTsb{IDkVXl+#62;KcOTOUFEK~al+!hzyweEh>Aq#}jRV=z?m!F}n!D+izc7XC%88+3XgwjrPayP0{!=(ASYvdWf;u zW0}U;Zex8Qs2dDgsS=a1l5*i7u&^fAw_Ie#Lmcc#u{ZDI9GPQf;OUYp$8pnczW7){ zm(MPaQh*W;_v|s!^p0q|kua0c3HyLCH6Bc?pAo{bRTsFut!?mfI*kxcCO6 zKTCGUp9OO}B|oUg4z)12Z$Y>#ZoUpH#-vqFJO{=EPT*PB$Bb2EL>xyKSC;$kJL66A zS_Bm_)4r8f14sj>QTk$>xMLZ{<}4*+K*)V3pdIgoPQ_%5RmuWv#NODYh?TJs0!UWY zQMf(L@X*^OG|@5I$IdM%iv~2@5ptzS+YKEI^|5Sa3|80dNZY4@z7lhw;m69@GAL6U z%s?IV_c$<@Bt}b&sGdlH)37>Dt1$6w7yAm>LX>Y{GV>q-l?!wAV`y6MoRxFxW zI-N>D2L1=OAt@a(LvPAZPUrre`s2);nrCDZXp>R(5q-^qoXC6wi0)jdQ0e7+Q zj+t~wi9?A=3cY2CVP$lg$>Qv{7-z3sz_RKgx*6 z1hOkK4ZzdT`(u~R#`1X>()P>#J;ok3PFPXkht?mKQQGg6ioa*;w1L=z5*-m~hR@pXgsN$^QTzE*QI$?5E;9 z#;%lAv5sVKLPiPFQF>bA?c02O-{$IPv-q~5QR+vQU1{f0sgpV&16(kHfLG#@J5oEY#EqoI)_j{8{Zp|tg+%LX{U}_592KQb@KHMQUqHf z@A){~=na@m*EyaflA4ILFgOB2A4{8dzj1x=uPGNgB&u4>!!I*{1TIy9)GVq8w^Dz> z!hDu0kylTjRpixhK@;+4m~ShPEWJVd?Y0+@RXW%XVOEt{oj)OFs2rmn>~?SUe!eiv zB?~EX=)11VOmtGfw9-WM@rP!UV%IjkymZ)L{FX}TQJ%@bht~WfXF< zhPhK~+T7{RkFlo`GsiAA)r<{y)x?gc0cpL{!zZxJA;6uL$_!fBAQ&W zDXJi>l9IPEhFEG&k*)<}rGftdOITR`aj4Ks*(b!DnX(QU$|G4COvuw27em{Wy6mKR zC2z3W*y)1$*fLe<&BLG5PgM+((}!HG(V7)9X9<<0G}6;WORhGaVoxv|U$0ZPIG!f< zPEih*Dq1d5Jvd1u3K7QlB%2UAZPxz)j80F2D+rd8GEqGX*Hjr@i$(!!swg{XQ@3;a zjFFd*j)J zB%@5cDvH{li7-_2_D|$3WwV^GfI>O4{iv;bzvc z%WDJV8+gYyS#yn0ybV_kJIh2OTA2+M^-j@^;y`-%we621EGW(_^ezs~p^JyAqL#8c zLi3lCo=x?Ur&r)yoN_gxq4j2hik~T#Q$am$u}#Z5O0d;!^=jDl^$QM%7mCr@%Jc!9 z(o{O#mB%-CG;o z0YZ?e$8@=2YD(p+qM(eBl0z3Y;U87PFV-$Po$*x*4-#%Y;;A7>>oSUzT_Fof0R)mR z1&>X!IO1{aNqt#Ml<{!QD5r+LpwdMyl8qVG;FIbi zUJ%jEAFa81hTCib+i!e%nW0nBxc<#Oeql8gaf)bKNGe%Mg>b%}yMy49zQ?u^Vr+g0 zt})i;3nN2SB`gGP#^5l$jlSdaZn&?+Xdt7jrOTNqD=VtCtZITmEKOzk7WB`jiuxnx0m`03koi#&D#B;a>w z>Ie~vklvWeg9_iS-hZ|cVo8jh5#+oP7Y#{KEo5}HQnW6jAuAy_9SyhB=G}2lDFMie zlPIXq>0*wuSs=@$1oGl6vJE?IPT+R2@q}@(S!oXm%3%@1T{UEI8zJYi^8MHjxL=JE zlA^Yx=cS7ikT@Tn}~%S9Q?|D zQpwGAJF)3tKej!1enw0A2=NBhL0v%Q7zu#vzgOsOk3v3XIf(I53TFu%hBgK^8#b<> z_Za9|BKjudLGafpTZt}Dy|Go10)t_ySs0zPf!6pOtdM*aA&?Em`|sBTC?#Baik-XP zsKyxWVeHJqZmK+X#-T4{RVuYAIxt^RMi^V7oNW=MBfvzI^E_7EsW(>qesIcvuzW{U zXG{QxF@YzDjX&xK-xXOS&^Rjsypn4uMugNO~ zC1MdYhRLCcM*AN=#~EaBVR)@stNr;!ol| zq>3ElCmYWefV0G>`H`2en;bv+6JNyK5(aZ5`TK5a^0mNc=dk4ZoM zFvO*X6X;%ZMbx}oMvG$&pNzt?{=~}o%PP(#L0l% zZLj5`joGyji(!f69?boIZWRuxxMbK0{KN698nwyWN^8WyQHQz+IvOoPXmP;^}YEd(R zYs$o%e!JiseFsC8($kB>O$>Iw(u1xF3PD7jk72N0*kW%?<=kPC7D=~fLf*c+j2EIb z?2_P;Nw@UEDHNgUC{-klhktBWkc|>9gKHh_(%9UM!LhzKVT@_deLGC(mJURh=Tn z{kJ$89`B;gmo#()7h!IeHp0uJF3Qd%f*iw3MR+H*`O%#$PrqaN#)w|Y=RqIOhc%Hov9pyYJPnKo1bu|XEc~%Hvk$;FmHUyEe0^LS9+ooLf zN=o%*^fs%1U$!W=V%DCp1r5L30L9HFVokK|zf3DJaZ8vGcQ?e?jJT!DYzCrtz-S1# zrpy5#-%b*&p=kwe?Y=cpiyC^M57mWg$}WqV9K%kX`}D+`38AE(I@AL8I9H+Lv9r-U zB%5j;a1*im2O`)YBc3rLSd0ETV_K?app^^_&)5@=M~h_ECe%gmXkliWG)NJ-b}^ z$3nuMhfvTL5KBp!*Sz#KvC^Q~kP^XeIu7T)B;go3HwIGF$t-B1I<=`PbXvu3Je*cg zi;a!(*w>O;R4&p|km@x_03@=G#AAs@C|Bdjjhd!h%8j8)$sJK{3&h22d;1R9IO8kX zz9wX6lDZ1O6a*>&))Qv8d;W3V#?dKaWu+*uS5~HG)}#JnlWsU~ulkzQe`2e9xkk0WR@gA+B+ zrme^_+IEIYe98$OB{8L`NL*5B&(u>En?vRV%U&X+gK%`&95F(N;yLUeQI@8i%D03hhFrl;3OE60X z&=_3a#~fKzow(dCqzMbuM>*#x32*tH4f=kVhCKByA1SMQk?mKG@=FN?JPgTP9!%?|WL_{{VbaX}Fx}u0TyxV3bBTcVaAiFO%(#TrZ5a zbWa~Opcc=^%u~id1IZut&NTAe=@iF-rLuD*%OFw!VZFiXF>F!$Qz0!xi$s+b ztso45ZZ&i`&GC~h2DpaQ&atE#*sa>$KN!+n)e_}S$zXIx5vVFUU$MiiZ4+!ZSd<%o zJ+?S9PAD-N%0a&O{{UZ{HWyD|$sHWe(MYi;YvHqJ-3uHIs{#}AB+(#bPtODCnADkXkhDyn!X0qJv z=Nc2SC#FbLn~xqb&?0s>ltX$6I~{?xdXpnbXYL3j zdtyi+dogvIb1lh%3PC37P2Rt2O5C`Voo?S z505-?QI*vi>Hb1}=s&Xg>5De3p{Kdvt4^XG+nI5Ed29CJ-+gI3Y}#Y>i%8Z=PCG6tjo z`i=YF9T_kw&gHYO#`0?ve0aLDYDiWksCEkM;L15)%)jrBuNk;SoW5+k=*oOc zul?J?wK;>2n2A~|Lck~rSOUyW_P#zV^6k!VN7H^Pm0PpSvZ@wQk-n(o zz0K}^tBiaWS4{gQDn*PHbydjp^x#*pcOn)Zt*&l7e!a06c!VxiPA{9!Hn$YlVG#gNtaOyIT}xvR3#Np(D&*vzbjJE zBJ@|+RV2x-Q_V6&5J`T7dH2PZM)X$nFAZiDwKb#4cLS^`k*qTIAP* zBf85@LrJRaq_8)?Uf67Gp6CvWC$6l7($pf&2@fPq=~T7%x%R?kT%LxGHp@z!;#$nF zD}s)$|Qi=^Tog@#c_Pw#s#B_-$su{G(Jz_g4 z41=)@6HwU%w%GesCO~N!!nr8Hi0+|Iugh+t9 zu?J)Az79CKN|5nKrg4`LQ~W*2DssHC1vT;n{pni>{{WcUt|1-GyPte}5B+%W+0v2c zS=MNkStHLJYfdX91Ck!V0&WOi!?ngdNlm$vYh^3a#Yf9B%M?o}CPOyG1%cIW;GA}^ z<7m8IsJY5`vK+LD>q82dDY+}BV)r16`P=#*Y%Fh*vZf=6^OmOK$+Ny>qc5yblB8o% z3V)pW+-`o@>T3EW(=|D#AH&7))6*7T;nT+#p!%GEO|EtWd~L@?TzPE4$6T3adlZvG z5|yJdNF??gR$(x!+j8kZ0tYj8zY90ame{3|NV!e!|&et)`8RMyR%j01o z`Jyg|ZnoR6ez>F({TU+TKd+C6vh1HJnt0sQB$c&N7CxfQc){_t_WNSFBWOA)c!%OY z&gB#|tkb;orqRgKfgEak00#d6pVt$|AK1;RDO-&sK?rFjn?Y7(XJe;wY`@RS+*b^hY^p8ljsq9DXKF{x};$xOqygO_B$JSJ@M#c#FC-f0a8Yy zJza(RpT;cUle#Cz*ljs+6^*ZN&|`5%BbFg65*#5LYPRR`fkp=i;>^d=NwvFS>qZ=O z>!;t$MCT#A!w|4LdH~e8^ih)E@Fwo3TUni~}O2(l4 zs#5U)EJB{=raGZX7%HZrwb%_qp}q?p5VRzfAX+oE@3F!R*)>x!p>d+tTU;C?*2D#& z&TFYD=ZPkGqMANi0kCDiL+y@vLz$0K;7%uLGUzCvq=roGro0o(!A6UEfxn+Ub{OQA zCl+22O<6v1RauhO$0YUARaKWQBnh-}lC~T5B!6sjNwqB&QAMm=S5j$`w=<=ot&xZV zodZ*}zE}V+>9^+@TVeR@g10|eLsUUbv~fzBmIxl|lG|;~kKY%POG7A7+=@EtstUT{ z6FLM2Rf15Gp2K1d$F?33_8tYAWtnwuQCF7d6jDc+{K`r*I%bLFF$5QlSlARjNFw(e zV(BJx$!x7phS^$FBBo(k6pXi2l9Xv1_1N#X_rtpOGqki`&qtTg&{SoDrm~JXEUEHz zw$?$p3{P(M7T+9`#}-XFUqp2EH7fGc)f$|_jU5^pD|eMZ>IffD->0@I7$~CX&{BT< zYW9TG(lrAyX8D+kD*`NZi|p3eVJnj!RY6Pe`W(lI4SG}3I>cF^H5H9A%|< zJY~vqgT42;Jx_ciTPUTV zl;ApQCbVlSMP*}uNhaM0!n7k{)ciR~M@=Hb13thmvMdO~q%E+ep@taFjlGw-#S#~G z5Fq80uwDFjI9fVj^hZ2MU5E^&PftILRWd|MiicU$+xW2 zN4wJSt7Y|+^%6}sUsjF0OCXR${{VZCckjLMQdVjzvo0CSDrbtGST$4zW^Q8LUhRI} z`r#)8%+;Je9?-<|H6V!<)UD>V&9~b4=XjT(C9r6?DmoZ>oZ4vxtjwf~4`bg0f((%% z;mDcFM2{e+P+CPzY+L@4O}6kxD58@k#1oA&^qnF!*-URA)X^d3F89>Rpj%f$P4U?r zoDet}+4wFQs3NGMu9B9i#<^*#NaeyiS%&8w5%L9iY@sh#msT_vO14j_>5nmgQI4hL zM1-)kJ@fM{E@78TsovdB;}!WAWH`GDq2n5PACP8^_XfCAMDS*_!{m>2iVQtvyAPnYCe&XjuSZf4JV* z?Ee5Vuv>r(ltfX4!>Db|8CcOtt$MLpF zCU2c^q3nZb&%2YYn39_X7LdueXA?0R8aW+XC|wYrXgVdBz4vN(tUl17qmwiSvyou&Sx ze#hSof;}p3P3^eoJ7Lhwj-t9MdtY*U4!@=xlz?SgjLuLb{sj;>(i_zNHFzG~ag3b? zS}-(?h}Z$+?T3MzBmn6idI5%VB;jL3jeW0hKbHkFbP|;(O4`6%2CQZKIp-2NC5RXE zfkWuErOY9wjhvCP>^vMSx(a(T8D?r~elTP|HWbqs=6KzS8YCj&M`L~VIPv_6Jaaya z@%}t~l_Y!iT~``9X&j#%mML$>I^y}kGKpnps#lBd*v}@QW>okts5cV4cQtXsH7D!vak#oSog!nKziu-8}`Kg zlbb52s^b0_pn0vr~vPzC?vouIGrj1v% z`it~F`0}~CI$V*bt)d)NlR;BSNM)&v69|xQB>s5L{{TzEON`!35$BNJ zD>tejq!b-TvHN0jlVMaPRzq7<=^>($R1&mtY6DO{{xK_IX?7Yo9;%wJRMCj$G5Yyi zs&9J|JDg>+CX?v3qTy*N)}g~nvN9X!VYv4mKTKP69@rH(4WzOcWl<9luBmdu#>Y^; z-}c1lX(W-=JOc@L5o(e>+d)529f!UtS|=8PDYy)^YJ(dkJME>nKYVkzTe6&x`Mw#{ zOLasJP?kv{e@XTuwhX$Wk!XBB4r~yT1$ceDu-oW;1k;l)s;ka{{RZ;qm2OcKnuV1JcO12D@ZmM z+Q+|aF9yc6O-=BY8Kh>Xma0-WzLfzFhW`M3XNj=$Nao;2A(>T7s6cYSfqur|?}c!! z3f;4+xGk#$ameNtR?NRB%Q`KDi!wB9JzfCBbDrHx|WZi;(uHqMIVi>4i>; zwvgB^y(4e^-q?$U6I(v19)tmQAa}>~F8!Z_T4EFoy?5zhi1FQ_r1hho`bS-bx5LxB zB&=rO+-%+Pq^XCKTOg|vn9*Z4)!g*QndM7@(ba-0EBkZ~v6-nyJA1A4+j21+Fi-4X zCF4|{i3jk|7|CFu1LTZ)6xqza%EBT#6gHa!)EsFl(8}5fRoI)@UiQ~PRQ&P zfFoD;#}^uOb>p47KvfxaDV{dufvDozQ%q^oC4wLkTEH7@ZQmVj z(m5)|RRwS+vs{a71rO#7}!6auRo0c@Y0jzDl;~d#>+p@Uw)|nBF8dkXr zwU4$R9F%^fvi-N{CMd*kg|+?fzAeV~a<#-qHeq44t=GN_R5Dev8`-4h4J7Zsj6tKR zXnaOOtVNk`f3_(Uy%ETobk657QtxE9TN~dG$W*nV(8$vURDA^6`*gvy8j;3O%)pz2 zaqr`7b2#44g*LQuBGbgEE&vw09-|h-lVoJXrz6&mR_TpcwW6}>($+eG z`hPg`Gs_}e{T`o>1tng`Rp<%7QPpts+!OtajkPwvLkdTz6&L6TJui+2iYePW)ZC-> z2t&(Kio(ZhTWjOcQBNNhd8%^f%`&2{M29fZV%lP6Bp&-*mQJOG?`(RIno_CB9wZ|ap#7a>7*Ym5buGL?(GN ziDXHli!LEl^2gLb7h8U~zFd)OMPjTDvp1TfG%~o-k~M>9uqqDL$0Ke>CP%QENokfD zYNf4`7fE!|(-3t?I+kYWpbnn+DnGF=MO|)TEbSw^HJscK+uODh)zTq3AWD$cl<}-H zEJgvXwe?_o3>#^NJpt9t4IHpb97#~17Lq2g3~YDy#iKiPR;_3|hZX7Oj!4uQWm^z} z;YF=rFl1Fl(P38_OeBS&Lo*E#%n1f28=jqyOlUe(EWWxa+7Fk48fhFon_0H)dlA>| zi%~T;v`0}@@^g@`vLk@3j>LcG-whb@Eg3i1kY`WCF^L^uj-nYYF;%dUb^+JlYhT+G zo;H??N-6YKXLWF8`Q1}Q#VIAQmu*@$7h(Q!%N$daAmCW=?jOoVDnsm9;!$3sk`)(?%8-0m_f6#>5ZP`s0`2S71wI zdEXqtnYsKzKe|qp!{R1IJ6e_QdDto?<&USxr#JRB58Uxhxfv~4(%0-*&bz` z%&+qIE@XrtG7wiu>3mig+U!{^nW{|YuPj!Eox%WiJ#B9n!^<6oOk~;JO<^4NQu>P$ zMTtL*I>Z*!A~jNaWOiZ{*;JB3{e~^^CWx(@t{BSJrVOr1HOVeuHytEo?MITUoocm$1VlP{fU8VoO@xH^!hf zY>u)Zilxf}NI`e*@?FoZPsw>Z!>V1jbY-^S}7SrjtcEIOy9@ zd^6*Er&(&LYBgHQ)e1Vf8s30#r#Y3cMmsz$h0< zwTjpqd*RxCgUNz_>C$G6w7lwU88j}h$G$Q`wPm~+Z3K+6O$}z1xdBx+9zi|vq^vhf zM2(hZQniwfpj`s<9!-V)hW)V05fMqCdTgqdq%vuBJpm)B`(sOG1Jar;U@|+Nqng6s zsO|T_t!NB2qlPzlW2a@4P1V5#N$t4CNv0@8I@CNWYEgCH>yLYn&NEg~HAf7-YT1f~ z(-xhtChUJpVoEJL5$~c;-F0-q7B#w$}|dlnkF3iN;o=XS8D-eHs1!o(I4(OiyO=o zox+=uafM9Di8fg5mr}9?`fg47VD>*GQ|37>eMvC$QDS8tsPCwsV~xS~BX(o+ET4>W ztjnK6RTV~ExRwflNj~6>&AQ=ffUj;E&U1-=ZoMO{sf?2Xs#z2swg>HOHR^|57Ss#G zanwfAttg;Tp&$ax7pSrO_QF)I!fBcq!)TwD^1Aw@RlbAd6VTzUg&rtg``Q`1@j!zxfTIdZdz+Ny|aXzOqU#lYXmgIVRttqc+IuAyT<PS^Grv@*V#7mYrQyYM|v z5#+UXlgP2jO;BMD$#pHTwfx-Ut{E&>4FJ#Zw?E42C8nsOF*HO0cGl7oE((tr?@_gA z=9NdX%O|bOxK-nhww|njZKwmVzeDYVQeBa5`ZrWuQB6`Kc%RI$?Y_#S5I}i90rmn2#=K z&;I~JkPlWBNsUOmk1#S>Nxu67wedv6`m!3x>1z}u(MK@{Z9ouy_|%w5I}NlR;5bE}(6Fuivf~O1e5C{{Uee<7?jJYyt0tmezq=9Th;iAb{OI_@2jd z{S&2JkT59aE;=t#F=)%vBHOY@t&(&6X$z5Vrvaq>nMV5@S~+8NAUfK_5pj(b$EGxt zN?gx`a-7I&o`MG6#emX(BxABZOrz1v@vAe{-w5)V)U`CT(>1%cpgdam=#P~BpFMZ&q6inBkm3(EK@@%CR)cb&Y-I+0xSqUaEVEFiP~e8#eq;aH@)#j z(^?EtPRTihT$67k>@lrTVcM*rO~v|PCQYFTxhDG_!>$^MG{^HkkT0g)Mj0v@CUXJ1 z6TfUt%VRi*kFd4;;)`VZWBG&+SEl0l4LdVH^H#+gk<1DQPj7rX*n~eYWz)-FN#5rL z7?YJXhdNyfcK#T#{c%SmQKCrcA%TvCI@@+)Z+vL7ZCN-rQQG~jhq5lv!@FI&_TL3C zT@wZ<2KODt7Mo?dRz_sCi*@omVu*_F*)5foZP%~c2bCAo=wl%Oo%-$Xjm$=vy1fK; z@r<_gYNS+VS!+tkSpLe~ad~*T^m{*t^4E)*yqz=EGQK2-GNy{I zmQ8U=0|VcGBLf6ljWc<>QD_O5)Oo8V ztmNCy;|WX+mef`8k_*P2dWE<4wly&vS#eETif*OQcv%nm!!=+?vZk++Ff>fZ{{VV} z{jj`7qRI;Tw%kbx9d}k37g{$KH#p(ieki7RD`G}j00pC+knMzf85g+~GvqXo)6vtW zh}0$CpptFxZSb^aX>#oMFonjdR2%K4exK6{;+SIEHaR~M)Xo+;>DR`taQ^^obIJ!o z$z7ItjWtC=YNn1R+WxmA`wSv=*!q&uP^(%P^BNTG=mh@&d{@4SbU{;;#a(e!Oym78 z^o_h>m3uT>N5bE=FYNZ53z;_&Wt5uoY2-ImTl}+|-F=ky$1Lzg?Hw`5ne(MMhMDA* zV6r`yVy&bB*?{apvD+NHYem@l>P4KYu(Yf+%mv4&eI$D@-}S-bhCr~0r-8&;6`~-B zi1nLyJN}qX2-e9GG@qEUYDrq&rES~Z*bXTSs=-#0oJ1p*JrW}pFC2_HzQ+yPpmfJi zOtREQQQ9OxExyO^=NUvUR)(ug9pfy5Zi|0XgX9c7YKh$9{cvj zP|y=>d{Mkri5fZ5qn6OO^IMFTo1b9^7!qln12V$XDH@2?V{X<54M~Th3Yyqy>?9gc*qv%DeUA3SJs{ugYRyjyIf<+; z6j*w!d>yKJfd~S~=z0nGZhfNK( zI-OUNLwV>2TqK((LjW-7MImDX!CSB&-wznN3Y8r_IdlZJ-L3vGiqjrVC1a8h(Jq$U zc{pa95;9C=@gf-YfIJ^35#rOb&8DbO#TX{~M%$jJ6@=~49H}Z1YZ+xLAX@?owfy$` z;_{MCg@45|DQe@AQ5n71T!!1HjBw;`=^c@AaYI`&B6dVuSQ16AaysC`Tr|l_Jl&8~ zRGNj-E~?*E_Px3cR&u(blu|*|qe?kfvA@)J7x8Q~Q)JwdD`b{LtazO1k6N-6KVIDq zIAf8lybh%V@pC1p%nTs2NT3$=YdyWO>b9Wh^HOfvG&5_t4hY}BTVnR4h{GJCE0Ef} z#c7cCV|ycQs1CUB{{SJCV_Xko!i1hrm4DC`Rdl&}2No;KN zFqk5NWC5c(%9XJ`H|Q}>$<97M1=xQTjrlm`$5Jzub9}Uth{0}M!Lan(zu4oK$Me*i ziQVLQ5{y$Rq@r<|)|n<~1JT|k3-zA17wC5WhaNs@wUS%2(Z!7{O7vjlrZth(1Vu6- zbW~oUNxq})kCV>!T}PJ6dddi>VTofB$XOUVl(MT6>C$n^@6hxelhGLJq>{d9rPo15C!-=|z2j%E#qIn|L@Sa?3+{bWi0QU2~AqiZ8!}cUOLPsR(?9vWh%LCu}Mf+o> z)q%i@mXZNc71}eaW=Uf7n}4L=d{r;eSVfjG<)mg(!%oi(Bh`CY7u%g@o>g;Ux z4o7f0V88O*ZY1{%p3*!%q$6m_G(mV@~J|JcsW5l&t zwM|2pdswHW0dBx!s;fi{$L~3%Wo>VAZ>syBz7G^+DXJ-@noWs2Uk;##9_5&*1eNPz zaNI%cS9FZ%)4k5a8;I%A8y&Vczl<#zyCW*5QoxXZ(}q-uzvyI+0oV_6dg8hTF=%O} z%xhw%Rk18mY9)>I1F3a=m-XInz;asARZ{{P^!|lE^Uc)V(eA2R@wXM?l z1X^ToI`YU2p^s8Hdb!=)H(-JzRRc%VdpXDc}9cWS)sdhl2G%fm* zwg~AQk~)*QxgCZI4N=aLDZ7S7BL1O<0PPZTiwCeLNVjv1Rx%wNPQt@}#GGmfWE4`6 z2~c*%1rshqS5j_~Ghd~Fwhg2Q6G2b#cZug{*Y`b2i7Zi=Du%y{oFkGQMVcxf+1H9{ z2DvDrjYm@RE&l*a9%%!EG#Pj7y_hs>C4ON`ObG`-yo?9q2=a`f`!uvavldz=A2FR0 zS7IVS0SE7e`3CsQsQv_ShF>ILrA2Eg7reGp=HOxZgNbJs!yX%@kzO2%DO0MKZCiQY z3n{wMxR4MlD}zQ-A4eHp^t zkx7=#QtclwGLvv`=>x_OCMN=C%N41EdP?*mR@OZ%al08R89qvl14_CO0ubmOKKRu` zSS*=oQwd!Tk^%`EX}7oe#vM>hxm-vu9KXW^THBH5f4&yLIWm4xYblXivvdOmI|C*e zC|zk3KuGp13t4pc-`f;K*(_NGgUk!+u(JSvKro=DJY@?b2@G+CCgqpUOcXM(>2h?Z ziN_#KF&i&y{qRBvjXVMsXt_4NxWa-7w{zR^g)t;G<-l%QGT%+G7*IrY&VG+d^wdV! z$YN?XRn^QOHlu!C!uTv!EU626buv2weID4Cu<`aJaz#yTB2E7xMSwqBvz(L~kFd zqfsDK)xwj z2~YAhA??c=SbZUfqWuN27KX4hmcKcJLn9DKaJ>!vv69fQU}=|Ee8`eIW@whgvyVwX zYzBZ5XcATn%UI5!mSSvr+;+j@A)U_nS>6^%4J^TIOE&2CK9UD-I99(# zC}zqMi7BaSX?|Wg>Xuo=D8XFr-jVJ=IHXfs6_V#hiVBpfrW#>;l!sAw3DU%#{{U=y zUK^Jymq!L=pcykdDvDWbgt~QC0@m+rdYP-Vd8?Nr&r>6pHO#qmRK(3C`WskzB=*Od zDN{Rf#j&*%Ym-j}4P@eywckoCj0hm~u?KtymW#>`i@CUKF`+>+$fZkZB1csRZ#O^N z68X|#hBi=Uk=A5Yi(gF*rf{NkM!HO+p&khSxNn(0igEN^Wqe6ZnZ^7Xg=t336IeC- z;nc~`8%(;V%mj>XrsHF`OgAGapp?u-#hS<4739frCx!;<_d8&w%#{VlUPu6v z6!rG;gJToLIn)KkuY3F83l!{-RxoWQ!EbVJj2TiT6=pzo2W^SLvQ0P9AgIzsiS>Kq zSm`?1C(M;=2K<~9_6pf3sXZ)D`NQ&~IFo$9RNu!;E1RIkDupsEfazPX>V2@V$twej zGyH9o$C_}qV-&C~&B$_qjl%(OM}vxF%Oq?uPIORk9}Q(0-w5T^Gg3nHnC&ErG_&@; z*f8>C5%b_l*(GnnIvJ)@OItKLuVCsN5AreBA1QlB8^Fq+{4cY$PLQiB_Fho@NXl#7L|KGL4)>LG zlkL7CEE9^fU*%0vdYPn^5s7K%jzzwkC5{%Rme5quF=<@?0L^gL^(X@oZu>KK$;P5U zEK7L40+z?5&iWaF09*5mSvM9nAWdb8jaTi0orsY*3K(czKacT-4IQIVyS455V-Cp- zqUToQ&I%CaZ&t;+ZWji{akHhn5v1ST;)+N`8x>sXD}6@}+M&OprB18r0e$ecZX<)( z5;}Oprl=QM6wJykwa;%D&Zrk>88)`S_dT!^pkJZ;Mhjol{V|xH4S!NQsx1zbN>LwGc{3dOJ93gt_A^%noPvp4MxMk>xJWHY`UbcxEt7c z#^O%PifZ7)s2E0rWu+x}VSC{QOtz-01l)GOakLvWG#SjWkPDq2F&+ac){7>n6$enT zzB5!)v#-7Y3f>{eXn3C}s>`zoR%%L!%yJ9b%~LyK?C~+hd4^M#>dvT(OGBm_r;f*&PVHrN^P|797?AxBpNq0Q zmpf>_W*8)rHN1_tH7#^~{{WQk2jpQ)S!H?UCUpU*qIH^@_9bjj``|H`VJ_><04Oii z2HM`>V5DYu$N&KJm%Z2z9fllJo|T?0COt|CHe+iX0}7}CD{XELlGeBMIMy#je20#^ zT9VR%Wmap39>cZ(w``VY2Bd-{Fq3i^dHY}vhty0^M-bE?y}cjF_84(QC>~jKp%>g( zZ??l2WOBtSIdVX2_0(;Q6QoH;b!(_M>H+b8IKl(cGYQ=cWU|-RS;w9B#=9{WA~lG5PLfFrZGb&(;`qZLK2V8NxDk>p!CvHkFiiR&RYJU`c%Ut) z2fg;b*vy(Ef^oDon_B+(`u_kP9~>$t$>z%`KE$C$qn5;m4y3l7 zlz9B&IOXw4xg8R6$rPDo4q%}I5vaA4fIH*U`6H4vndVLsgszT?vPh-nt)4bh^>w)G zYT3|$;^oJBxvp%({0W?oUv}wJqSnQe55@&P|^fey0GuQJx>b+abl*= zKhDncJ4liiM!NJTea<_nKAGpIDJ`IhnRy)xvUr`Fn9;basFJZX$!sW{d`>~;l)wkFz70%8T zqbsNzGYzkePT9RlsQzB&{o%H^|`a!xdeW`)5LIu|N-J}}b8 zpQ168maKg%OHC-8Mvt*uFu1W8=9C?sxMwvlv~*S)$m5l_VuJVg_ZV48V^v!^5|&ol zT?ZV|DT#?sV!-v^-xhiJLgu)Mi^a>Hbk!gVYJoPXWnzPNQ?T@o=kJdj4s2Ox@=8>C zK1L_wWBAf+$Z50*=2 z(}m-!%xS3`ml>XGjVrKYezyMj`e=Dj!Q=eXm7XSF4t_>|h7qD)h&gl_T|3N`kw{?* zwJ79W4#a`p{RTfa^M5NpBP(g2ed7KbACCyS+C^S#4J}PXA3IvnJP`@fl%@28>GbIU6Y3{!`1-#y%ERMhPa4_sz6Xb!$jH`5 zpv>owcw>er7G87Jyb>sKWYM4%y^Xq^#y(%j{MLNYaD=pdXOH-A8xy%lWxw}qF6VMrqaOnvwtpieqNbnN@jO2o7-r&@f*a%K22e{)PZnbydCp=9q^50;@`t#v zzrH-le35*wv)Wm4rA=9%;;uKBJI&U+FQk-HGIC^!c3m-V{I=_Ew)eIbWQ=Xz&RnzS zssqUZr>dG~b%@n%b6^PSEH8cSkDkucmV*h`VDr(Rn{%wXhhlHi{d!>?Bw1{VyD_F( zGe!t9PDy1%vhC4sdY-2cXrhW`Y>&-}gzWPm8e`NzRkw^5nWc!EDT*2z13a>ZmfCdM z+DEX$sJUp52N1}!dUnfabg58Txk}H!s@J$4PB+KLp&U%(<`mTG<|>U~pbmk4qCA7% z`(U_Buv%IpPAtpiRaA~B-DKuycP7>wo$+WX6^mUI`R^Wz#?pkv9=i~>79aP=a>vRd zNP@GB;fF3%iSfYzZsN?J#QDh`CK$m(m@bG z>YOPK=l-ua>BWzUUb-_Av$CD9cK%+s$DyxgyCbmxux9(7{@5~C(X>kpY~y9KdFg~e zf6??W?7fmxWEI)R7v}37E>%SsPnxMqmc7YHiRekS&ww#hG*ayPcZFzU{i41Q=hEeK zr3QBGH8(jEoCH8wQdBl72>xJx_*-aZlRg{xsqnKs_)(v>U!G;nPEY)~cW9xQ9+D+L9D>bFar5TtX|`j>HhV2u?X zrM-gO0&uKa3XvkY<;Y!oSXr>CSV&|F=rottdl20K!8XJ4mTEMftR|@ubjB^!j@w{T zDv~a^!dIut@@$=sflV2ynHOLtliTh6@ZF6`bY>)NNu@_jZYY~WAVXU4^XNaRZaR5F*|5| zbZ#;p4d7>%D4;Y|ud7IsS#Df=2KUC~%BZG|ttZ1=u6k#QsHx2}jkLs}zV{egX5t6` z0H!NAK1NztTR6z{*{Ik7G(-7{n|g<~1-1&NXz~oxEaF5~%VSw7)6memS);brAfHd) z2*z!CHA|DlV$q*UgLOlD6NPMR7OF(10c58MU`db>xbbg%PQtB~L`PCgk?Ikhz;INL zVljr|$we9l65P77n=@^`9?e2SqBuyBCoIii`-A#+7{auuAjd{@hk(Ywrtar!;0&Ll z&8XE4mPLv*0GnRKesH`;<>-=1B2>z*6>5)Dk_{YQV!FfEUysg9sC zQ@m|*R2Aud_zc?{4DLB_uq19vsn{R;;9D^S@U*T&`WTLdFYmwO7+@KY$D}5ZfZs?4 z$K8Ff3_FtYQ!8>&eMJM6wa;8&rZzf;6`K;k4J-iNNB;mgCS#|W;w+qpk?u(vz$JgM z7!-qSW9AW{uqhmRh$iOe{jsP~Ws*4;mjyu8V0scx17@HzKz?CaZybl%-H+>lv}!Ei zhO{=apdu}p0eksuGXe=^{u+}iC>AOheLMHUCqw@L*p(7eLS++1tbx9+ztCXX5gafh9u~+i`zB+hD7qkYxm-t_?<85B~V16=D6x88Zw@R1ztXBRAD>%oo$- z9{6fPHpr!VWz`xw2-jxR_B}V>*k1yYGHf1d0}S9arZ|n7#Ma2y>>cb_+`!H4FlmmiKYne{2ZK z!Dd4}`LCO%f~vRX8ktP06MHeZ0G`$u@5PDa?2b%|D9qKF8h2?5yPKQ)oO=+*9BP_8 z$>nl%h08c*uRW9aC}O9%R+UorK0VGkGi6IrDUKHHmw7J+K;`MZjbhd&Rb&bTu!sLrWn zrL8NOFNENklcL8l_<2EDPb^tf(DM~p0g=v-z*};6>)4z;Vvt=PGsIs9 zGYqztuRE!%q&$S!!688_DD@TYM~^t@h>~rU{{RfC{{ZzL9OSuePHFNPRZT)iRXp}Q zsEOTxJ^uKzNQ*w$;-A=BvZIIP%(yFvDR`N}>xzn05lb?E`L@1>Z*8xK*exF`@ed7W z+%cI?NnexJQOyyv#WX}RH%k>ekNma@O^VS4G?h;f)1an-hjkx(^@O zJe6QXNh;PD6LuIbF3i6S)eMV?Gkm9W6I!wZYXGhF0rogZXs$=kvtt!hfadWB!f>tN1Q#0RnV_b4MGs{EQorBvA!uBvX4x66wyyv!C4+* zE~<>aop1ceG?V&b>&cS#bNn%G+B2Dt!Th427p0b>o7HOzI3KP$VdZP=Mp#$;N{Rjw zW|T9Rq0N<8TEgsy+V(cZzsScf(4Q3l0Ah+?hXf1AMYKuT4moGve|TsiW-;&_hqw>_rlA>ewmhA zG!$PGxPG;V{C^~qYfPna&hXD3yBXv~#TO9ewSY7g@J*|ub4C9Ez88f50786)oHHbV z0Lvh@?6xBbQeB-6pF)?=G}~+7+x-)8f3d<%ztjFkHzd0U7AmoF-G%SJOi?8EGE^j! zDik2>Y!24n2GZG@_AfArZD0pqQO3LIn@mF>BG$3{;)-NSYM4~{d%mvi#ZnncA?Uh-*K+CfnyEGq6ZONL$qCVIB8)0UP!6vq8>8r-x zyN~4~&zw>!`ynkd-kUZ4BKnm_Tj0`TJtFpxISL797CZ0T2^DM>U(sg(g*Uk)1*9@% z)fQ|u3me}PYRXxAMVWw$a(BepthuAiik(HSF@VduJj@a-_5|RfW!)}dZ}ng_V(x~# z5o2rOEo^jMQr7R(ewf=aZ%bRX@A~0dGNSH|xDV#G+glTA%2{HQ>K7d`HacX;_dfUo z+2{WN8@?FR{88YVnh=Vaj4EZLnCwQMLugJ zyrzJQXbOF1{soWp$1fUZS7>j;o(sxqcn%ozcw@~oERka+S8o3R;{af7b5tX%FD+whSvoMrOwAG{LQ&a z*{mWuh?<%*vnzwCmrEZ>=s_OG4WQZ~rmSV8jTi`;N8Fx{N!#s!!6*6vsjrnN%*xtX zFK~C%Z?*pT4XV)hpt^OBkfc`p!{`!8s>4Y>-G10u+Yym9U|C9XW01{j1vWP6{{V*u zNL2O|#kn%hN)BDQac*vWdtp)^K+P$cq&%Yr*9tqH|%E9{&KGEVL>Pqo$*tLn)p%xc*L{`(j+Z4A~xS!cZAVvH@AFJFNkR~*k=YrwynVL-)w%>ED&z2{552nhL1Dj-XD7W))2D@QaDZA9WA*7 ze`Ak;{G=xgs+Y6xKMR&06uJJ5K3x??Ur7ZlsArX8P|^Z79&zkqoU!6gk1NSbHhM$y z?jTBf0eP`P|8n3p74Q@+2e)a>N?&F#NWwmp1s`)Km#k)=#M zluZPR8*$U`h&&E?Q=sF_;|7>B^I(qm)BxBMk9UU@k>s}J&=j=w6$(_y6*j)x{xReE z@NKRKt%6ClM6`6AwbLVlvu}B4yQbEXvMOMpX-9eLH_!{{T#R zll;$(1x+5dFTwd46{c8ZzYy~J<1y|K}Q@>nw~PN<%5#OJ`atkTow z@n$hBkj%2g1@4C9?T1%_i92y3laKPLk&n(s zx;G`-*ZX35KQn@@NT>e*4dgbeB`rtA9J574(qU%vu2k~;jB`NG&-}af{ zI%p$skzaz}cth2M~-W*vgilY~p{?-|MnV@l(S5{^5 zz+gyJBqhQAX1N>UZDh$0QpT>0{UobaGKu zbaOl|Mw9;lt;fb}#+b)8U7vDE(s}hUMmFvBjlWz6o06$AtHz9fj)Jnk*^A;HWSr`_ zsj1<=s7aZIl#gYx1paXp;UBUnqa>-YobUE^L8ne-O-uk)5mZ>qdvB;7*W6%y%35Ol zDZW+_C+zJWQv_)~Wd&g>ALd|wO0SWm-x+1}QQ}>f{5$YNhN&y^!u(NPEkR>Y;VIMz z&~+nF+;7(r%W^`vq&oG-$1FaJC~H3l+VyQtFRC_?^S~ZwqlO zV=R&7qG*;tk~X5Gk{L&^+SlK%Ir3vj=agxbbWlxMH!^72Fh;R=(|><`u{9n=AmY1Y zUo@uXyfA5~Qzefy0!aK~s}-Forb|;=7Oz&j0Iz++DXu8w_<#!uw5Ik zg`W+p{v>fE6qLY0M-`{8sy|FHh8oE}NVpg8_QJ|7y&>bS&!YI(jOjQZCCYOQu9lWQ z6^JzsU6j<*i5{s<#FbWKZ6mR6x48G{QE6;vCFt?rg&!Ohx4JagP^~N`_JASy_m{d(JRlrG<#IZnWQW9_S#vnmG$lmxaKyW0Rgd;GtO-)A7 z{RB%*b@P6>USic5yvN|~TU{7omgVR*5X4jI)(>H0x8D@`C`O98{{UwEx~)$ny%E+f zRf(|hFVpRV@}bryz)$SAtxH9nJHGcr7z^!l*V_#l*d8{vQ`P>=+(MUn8L4W)8p;;X zNcKD56}Z1-+*wJPd=ui_s^UzVay07I8CJiz-*bWWW>MD6-EKpe(Mh7BilP}8sA$^b z`e5;ixil>XbD3qb>Zh)#f>7J?$17E1=7DQQ(%7K zhWLZT$5O7%_EGW6gmV;MoS)?!196Gb13+ioF z@&5pp!c#-32Z}YCB~dw&%r!END!u{1vvNUim&HmLwS?piQoiB7*8c!F))&5l>7fQ9 ztm&;rpe?Ak+sEe`%##vm6u4D=7T?q_zqs#(avG3=UzU`K=8iSm*X`p4HrQ>9%;ScA zBuRZeucQ&&`{CL^v;;EvK?-GXi=^5)EpdtQ1C?}G&zQ87<^bl$(i>Kj?YQapz~e#W zNkvv#due$sam|swk>lU*fwE{SNzz1;H|3G^+#QDh0QSJK>c}ZGT)#4Uh+wORrf3** z3{9x0@$H6EMxl9>l2sabY9NYp6G)NN9U<&|{{W0PAaP<-ypyA(G~vu!I|L}8o$M|L zp19U-ESOVOv?%&wrvTWA1=#hsOdB^AHaZ#BYfU_Q!s_LN>LaCv&s=K-64pl@7)3PY zjgQlBNb`(loek8IDgfaX2Elf>`{0=iQzTUJ1b0LZY^L2$wlSCxbcI`)XF5&x*pE2N zU@B$IDYDvzM~VqG*q|3Bw(EYE?fAejl$=#Y(o8udupt#notw4D=sobZJVEMs(MxHF zvY499=r;Tl`e0bp3l|kfGZD{aW+P#7wYLY`4A`jy&&Jeo$i<|22Ahqp0*|)%3N~iH zMQwK%v$35dTO!z~iseQ2YmVO7)PU%st>U`e#v9YX^9%0mx^)X!onCK)#iJpMS(!vN zREX3nvRF5%Ph0z8Tl5)KXboqtiZd8@nycz6TT1%_U#4O{?YET~;>Jy^nE&W-g`7vhmA|UP+u1u`xF-;C^s< z0n;BrSuArhzFM)$Z&4br z{6xgXa3m$qsA=?&4^EcCa$d?5kk;h&G8i6aXF^9Ts*rZ-8^FRzq!mF6n&tF?o}FD9 zPeEdCtOuR<@-QIPnW5C#!So|MlS`#rQBX@DZ|B^R7z^^id;38)4S5t z)l}7ytC(YANjXfj((nTO!&BhW@X$wTR?>-k9>T!PRzkX!As#OaKhD=MWkO4!NZE%K@rz2j+<&DubeCX z$D=XDZq#)YdDMEXM8#%N{Lr?{KN~mW88ipcsHDvKw5cGohXAR)_Vb3Z7J^cx?pY0q z=se&VZ=!hWf;j#oTfO$frUrsz%-j;Cwg%uH_!c{QCjHN8aWm72T(bU8M?WOF02O0Q|tRFHh={_v* z?N`-S&|7cf#=__Cg#Q2@Yos#G7woo!jPfeAQx0iN?s}_8FM;vSE}ARyL9H^@Dww9y z5?I`MM-7cyGV5VUCdbpT?{2u8*I?5bBQ?W)A$PFuF_qngst3$z(z=dViPo|yR#H0= zg5?mx!MIy9mZvTGYLjZ3Rxru<`cLFo;ndY8B8B}9cvRba`8Za9UeRYg4!*syIx;Tl zGk~@suXEEGDk(;Si#OB(xW-|k@{2WXJ0H^%Xh)`KXfr$M^>6(#s7o(tEABQp%^5Q0 zlC*$3eX%BnvgVeyHOY3ZW1Uh0VHK^v5NQLA2D5 zDoH9;Jf(@$jBR0liZB}rAgH7q<~LGp>DB53&*uwc*sxP`6Pmt+?Xfod-wuR*hykZg zV#IlGCGH9I?bsfJ?Ti5pThqs+D>R1cuDgBCH)f$IC6GoH(Vz@;=_7G|=X?ef6D^f& zlMP9-#>20;^MDX&CQ5_>1x70 zVIYPz)#-#1ZEdbGIQ9dmqgf*n1v(fMU2VA+^M@XgI#flH(L*fquOU}Tor?<_S%C0- z;&XJ3MI~Nj=DntsLYQP4RgduA=VC36ZcVaj?`7jxh}KtfkRx}u)JWKm_Qj(*8ciaS zo}gCd63k_ABLX#Iw-+0g1a!iDmntNheHMd0GSkGN5n4OlnXDvVVcg>U=zW5=ersx& zMFy~+^Db;-@rUQD6@paPJ#8vHP&;TW3!x-44{rG6my-nh7S}~4VO=ow$Ql%Mu#h1H zp8ByV=S^vpL|I=DR?ELB9G8tec(zy86{nWs2<8&8S9dyvhhjWl z*zrFhjw!e7^n5u=Fr*VQDkm~$9Fn?hqQH*3d*U$4x{~x;COLDsvpEz=N~W$iloEAo zZM5&Q?~fVeSS89R_Tw34f{SIvE_NO`+DP;nQ`OV}*FY%0pVrv=Uk}Oom-cvGPmZAN zhQnPy%a;+mjjg4uTYmTLY~Vq-uUbLaklhwtx2S|6-z+# z#Pv&gOiIU4J6pZ+=H$!b%6uHQdRVY|FC3@G>QvNcRP<(|dWmC)m86xCti&H|c^SOu zc(bI>SH}Eo{D@pppUgfgWwj_HqNr%(k;HuYqdFoTOMBYi*Bp8O05=?;>WcpW+1-Qi zd0{SjfBu7K&G;IELiPETMr8b=SiH?;bJzfEI{q=_WY2~+=RKaZynM;1;>V)A{6+YB z)RM_P90snQA*LO@XWZYZ81dASmB{xVEXp+rix=%3!8sKpr8IOjZcUacY{zlb01n>R z_M_%vhBp|ko;&b-x0B?aO(Pvg`$=%-SDsYNkVceKGPIFXDG{>{te^{mapuqR8KoWx z==P)Fc-iC1QMNlV{j-;wGE?QN^352E%Db>$g^B7&J#pk@pOMW?GttK!F~ae*Q$Ouz z^7PV2L6XjqN|us3ikpwHDh}8D=tmTn1^_&Lf z(>b#zU{6vl=M|P*lWEwG#>dL&rHkUuc?8C2rfA)lMa-?Z?cWFI@)Ws6oh!$LqfR9z zW$`yYs+6>qoXIR#oh99^>`B`Vnpr%Cr#I2DL12S|jV4!3$9d&k4Gj5=(n8D~fj!5+ zTo0QnTyI3b#lE9YT zlL~R@sY+=km0^hsHLe1a{qWMB$|ywxu{zHEHs1wo4St4(w)evp8q9Hk)rqSZ)kDET@=3w!Z-45>|^tqw1>JIrS+~^Abt}f|5xk!2|kO?~Yk$ zrG;ly(${4Y6n~WFTxlQ$Zq^;gwla2rU~(P>r&uI&SPo?qT1jUOA$9My_xs^1c3|er zcy}li@z-gJDC7oJW!A5I{XTx!R_kQkncO{|<=M7x6p<-(npcW6nlQRl51`+mx%(VS zS*@Bo?6*iz=5_A|Q&Q7HS5%Rzle*s52l6e1=2nr1;>^+<=Qp5|u8w+96b}<2Pg6K< zq#SVMlf9gIJ2RP^$z4*bBuz<92EdJ01F7qPjVf9V}g`0iO^^c7}bOG3o3a7aJP)C^He&}ejM zN|H&xLK~(W)I9->T)oJ(fwnLKiL(Nsf_wGAu+ZZ*t+wB6YaWQ?k==)p&|d*G3S_j9 zR947VmItVNTSO7Gj!%ss6MQq2dJh)O*TbKL981U9+%yT7RZ-J(0#wyjQ?z28Z@DVK z5^OdDt_S@Npq|g9E9m$~fwK4E%2PVzbWR?vqJ1;w@~9Su<8ZgOqte@Bq0}}cmGpS$ z9De-xm6_CLRpvNmU81E978qa~M-mTVu|4|ZnUd^l?rmhKwyeMBo8aC`5_0o3+@B z+}!lGDIBus4jL+@&@$rH|7#{zk&xFeL1vjUMRvOwO8~ z2qllJD*zwJ0}@&sE~<*BEX$1P6U#WZn3w(V)?sP*i!QFK5lIy3QKw0?4ifes&PFkd zRj)y%TEMXYfHt@1sK8+2LY1peQ7Xq%BL;18Qy6b=HgGl_>~J4K&|}st>aHWQY8SGP zQ+xjaz9R05r=nT25K=x-Xjl(Ypa59)7^GVRc7~>AsGzKlqV zn<4ZC@NgJ_S+zYxl+qRHeKoD*>{foLAD&Z)deypxbGOS5fN)2w|&MV z%VH$k8&R6e4<@JO!l=57jUnuJu^V3*<@8jqlCai00~!$`Xx@ey)e}v_v0`t5#KiN* zl4w@C(xQ##MhL{8H^!nxMrl>SQAFZQ=?`~VDs`LfZH^+~+aHlZKN5UD%3>yxt!0q5 zmF2TDDDG}QwkzOVT>=!}fW+%_|V5S!_4;o8!!uK7E~WR6{H!-Abvo?Q|Ep!z@W5BC5=`-^Xa1?lFFTj%N#IuZ;c)WA zQKFxQvX+)USaKhGD+`{u4k(&V%k0C3b-==+1(`_PIJiHI4N=miU6?HM;nrC*miZAA z9m_&Yf6#4&a7;XmW^M4=mOWgmhmQ92%Atqgjq%ASJJ4*s;V;>Dh&adls;(%;u4N{f$NvC=Z~ZXT(X}JYGwvDB_-3V| z%`*AuM_98tflq;|erMmaUZP)JRjk&ulU%=zKNg zl1GuZMbv+MS7nrC3Jw5thM`YR@lLuAo z!}&(|rO+F*h*C$W*q=B&o9Ler;ejA;)2;A%NqZS%Pq12wDrwL0X`+~(?4uT0ruAaD z$EqqSI3pmdmARQ@7bfI|wa?sQkI0-?WS%I?v{cl5D9CC_DHPCZZn4aNvBja~N%kYa zy%n`T2B@CqpD>w6Us{9z0D~PX$X?C*4+>zAs?e*{(N<@9trfG zhc5&1rdq4=nV~8=a_aW}xTG>-lD13Xnq<7+h;%~#0L7Np-HJcyfhl8s4>)8*l-zyB zIdq}346W)S1Q!bdQb&MCd`-g}R%kgc%{>l%0_JqNj9S)@Ftjr)tE9&#@|O4Qk3H9; zrCgD>j!USx@6#GKDpX0$3vtk2?}r$7J&*<$)_b1VsU4uoY|WRe5C@EFps6y_lRa>& zshESXCj+spzoX(y6$RM-cE+IDdqc!ymi z*09?O&>qbl26zD;tNpMjUOvq&4t52OtKYT=XwcDTH?^1#BMQ}kyrs<-P4!|;42xQP z#2@C`*jgUT7%Rc(Z}!5p2P46MY)Uw*ejm|J#Hoh0Y|F74fd}!4=2|+i$)6L1Bx-g5 z7ToFCvE`lM;F+qyN79S2KWt+YynNO>24y$Y$FJiWj4@2Q-C|Z>~P4#9Lf^Q z8oG_Gs^jsD2hr5)BxP^vKzBwLx3)JyT?sRDrY#g4ge0hiPO)zL^};t|q6wLYBuNNh zRH}vl03Hqi#~9)oK{6u)Z6$ZNi{Xq#G_NFzV^>rcU7q$k;DMYcl9q|0RgR&g{{UKQ zWB}i&>4ja2NNT8JqKc}qL`@^|j7pn>?}mB>nVPJ}CrIRKxjiw|YD=~HZ@s)*5w$Ha zreo^!x}W_`Sq*MqJpqwcNV%40w)z+VewG{Gw|sKs*Fv@IKRM%ql}l43%RK8HnLw~N z>=&lqamUV9PIl2*7ZgUc(iNDmFaw~SHv|0NY-Kj3WFu%MJ}mi|q6*fYHQ9BNE#lwm z#ePXLyqR%Jo8*s|M^ht9mr9OqWOE>wZS{;KvP!6Bl9d*8+089AD$zqEEi6+O2=A~2 zY(X1a!SHe7=A6`tJeK+c%&SPIO>Yy@u?JuYRtMBYyzPVXNokr=k|M5xoy9}M##rJS zl_VaU{lCU5kL}qtH|!p+x}2mGw4d3D>AKM*#lo3u`k4MTlhc2d-E9b0& zor;iY+ErVd+T--c>K~2r-Y0FJJ?40c!;DZ}Z^Ygjr{+yQWk!bHlG85tKF78_jJdI7 zxn9qk$Kz&$YP3;i{{R~JO=+2B>AQs0dsec>rUEd6eU4rH9ALrDkt1{i3)|33SF~ zsY0r!Lul=VoSR@NaMORZAAkaiYAg%UezA2B(mM2Jt zPsUFxxfxkMX*&9PsV1bSl4o|gHF5$7{{T*rf&OIUE=i2P7Noeys?C3Bz9p|lMOdj+ z_l?Q>^%ofB%jf6GHu)Z|5657`jYEk_pBT8VI3y9~G9+>~wo`r2p19$bSve+glsRUxW0U2%;SRRs=P z6A;m8asU=#zQp?wZ-AW=bY-U#sj)1;bU3tSNY2{q9j?R!Z_X7h*n8|VD$8cfYU7GH zT2judW!!bbPE8D=tkY+(Mt)7?ggM_NrB9k*r#*_Db zT1ihWA(#ok0^Gnaw*GO!Y!%TUD1$L|~WZY3ga@sAFZ<07eSh#rt2kTy)3Ci|n+d zy%{R}rg~#@5lD*=tasE0aqWuyv3(4f`Ys-<%qCc%fuwz|zugF{QW4WP-v#qY_)m=^sgjOK#X7i|d3VyJbs+ZX zz9T&GQM6G#QS>!e#KBvXMLiw#Nw+IdP^5L**oQSSm9jjKi}O6%o}xB~L@3(?Csm31 zg~#6l($PeN>2qi}PI;t`h&$;IB(lx?O~?U>JqGvN8=CerO0;(q=2?Di!}G;e3PPY? zpRo&b)HjlQ?TJomh`lYCF_^YV98yLqV-$|kDU^b;`iAD-!?rxxTY4pbqSlhCDtcKe z4q+f{!HASDrm%BzNgH9}+ItTsgs-ZktE{7iCo(-V6lFj}ZnxN%?0>EfN|PfeV6)d# zR_4gnIv}K^)P7PH+@B}8Z#V0SHK7z_`wFX$Sz}1rQU3rGH7saI8cDwE@9l^kP>Vs7 zxsp&tASncoP_7SM2uDysu^-zF@IKj|77tGdncPy-@&u@{Fj%yyC#YSG`*g=bNh(N3 zkB-Y4P83M!c@@#trrYJ{n6HDyHjoRED~k29A2TTyn^@ zgNNt_{d(iJSBdP=T)Q&g5;%7%$oRi8gDaM%N(&<)ch$=!Zpa&{-us_8mTw_7pkl{w zWi&MvEd&9hMMyyjCXg6{d-(&lJl8#)Qi4b*(?<0R8bdId*IRQJ(tXr+7`$dlq%-#{ z%1adHn98!2HVSXz+u_o;vSpnV^}{@B%9>d7s%D3iEj?0)y7px~RD+I)q=xHcbQwhi z3h>CtlF4}tBU6&!=|AZo?TTm|nLTd`&6!jrv~?0gOsWGzA=r|7?c08X6Y1HW!zuVE zQBLz_Xi-Ph@UJk~boa$Mv3P@KR9PJjB(*s%SD8g$P74{}j7C|zdQa4U7~JeEU{*6z1pW)GH8sTRqtiB*xUP^ z@WUh*@cWJGGW^o2qB=RFj#KJ_p-f`^cJ{z@R+;QMXBE+AloC`-@ltY|Q!7XTTN( zq_kweXHS$kisD6fW2J#$HV3W(Xm*tkT(&hp3nljSgR0+b8~qWhb`WD&wv?kP-pZ|} z*hW!N3(ZcBEl{UbiR@Qy#{w~QE0NzlO9?DVaz(>|^$aYbeTmA>r;;>FJj$Eu8qMwF z3r!4|vgXv$s2?y2lj&66_;<0Cs721H{XIYi*G2xP46Sw}uFCqHc zN!#s*=Fpr~S&z+r0_N0-Gv)b>ElQylMpCTi+uIEsmcd33GT=TT%kLDKRZ{mY8eAX9 z#jY%yPV`eHWqku`R;s0Mq>^4DKsyfC!tsM0S~WQz#jYXBOhs!NrVfn+=HZ9msKQGZ z=zeV*%%9`+FD^5fP{|b0n}>|^1CJIsPl=_mlExP4C27G5z}u$w z-}_^pQE883Y50P#R*2zeQaO(q+&MigdVmHMn$T@tZ<;}IEcu32Rvw0{_&}6-nmvgCT}R&w zCK#*i1|0tYGpfvlaDT`oNR6@-w}FLHjSWb#j=M6Bz2%msSmP(su@F(0uc&su5zk_> zO3cc;HI5(y!jZ86E#uht1Y@3g8t4OMN{QA)XL45hR5>EuHa+l(zS!`Rmt@UPRaFc^ zBvGYo2tb7Sxwn6O7-gqS4epTz9#tz@+CE^p8np{!p`})eLYHCDWm3r(EylZCAY*$A z@AkxgHulXb^c(x8509XYnk@E44U;WYF9WlnJS0f3T=Jh$eg{rEi zsQ&=>j!lQ#rW!cY>_qGhWh~oR0n=KGd|qtCF%o0l_sJq&p1Y{m(!+lv9#``;W^%T)|6p%^G9S5^ZJ zdI~wJ8a;s)9V{(`_HM)vsczp<+Xt{vG|3}2z%ds#>48R~5}LG|Fl+B|wgnAs2xBQ@ zzWqiG6MH+<#9vWg1Ew_w$0TxVx{?QQ#~O`d3*EILzfG`s0CYjl)+FBosezuSz753Lst=&maw>0o|%fcW7Bbf@vE@LX!=9pZ|!%* zoGgo!=k(3R*<_ky2;el#r)v;)f6fv8OSP>Y&%)H-3w|tA8txO!lZLZ)VrI(f1(Q|% zLzYd{-@&#Tn?zKp?03X|8h!_+jq@1v!z&1)s!@34bI=3Z`{7c4$~t>ILyGgYgH&;! zTOIGy6s-w#%q-c6o%Gu0R_CS_L}es<55dkVY8r${=W!kWh9Kg#eTBbB`%mG=5d7sj z5iQiOKsUst5^3=~PyYa_Il;$>z5!HmH5RCIjvlCvsV0Z(Xc@G~tVdmq#ruqM$|Yj# z{FYycIn_NwMfShEUIEaQ^@l(Puxxqpapm zH|09%apwO3+a7~{{R)zz_(7OK>S$O4xYO3&ZGxn|8ip=yByP;e+JNX+4a{0;lCE^D zM`Ao*VS?KhQNF_9%vDM_I<9vY!MzBOM0MJ|M2$UmILcbtM;(MknJw5WGY*#NhU5+? zd{wG`qAh>d4&92Ng1%@wi!dX{U(P1o4$(4I8xL4F_rXqyG(I}w&tORa?_<{+lQ#qs zm7%sQFYkeE8;T_Put>2Wj>O>h28A;NyB?>foHRQYe^qFDv2C{1YhjzGXbbFzG4xrD z&AS{@GO?Ds5I6$eE!!36S~ZF^sTbH2xjjx7m6&k=wThj_-Z1MUN{KbG!Ahs4fG4@> zgyihMN`;O>G?qGu8(X$4rqVgwQ!99fD~~tJYH3B0eW>R))vi>moe~1`$`(YX#nmP_L zQWO>gdl7sku~M^1L&f2M8rSu~s~U|B9}_E$pSPSrwwSvQtmA5ImVv5gs7RNhvz>wS z_`~tDQ!xJk7II|xwZatnURA`ob54`2{K}>(8r`lv@jS4TS~{`LFzoO=&-Q5JN=ONY zmK@qZE{86wjDkD*O^xyAyb?NAcv*?6_+Q0YEQRwP9L#8 zOZfItROQP9N6v;sZeTANJhDf%`eI*X_J>;*f$K8*s(QF(WSS{MMIa!uur`AQwHYYYp(6uSiCS`OH&Eh^B#kF1Bs@-v&+5sh~!4NgR)3 z9;GHV0FV!ZgygzlOZ0SAf#FkNHEy@_=iBXqnqSCjAZmt75;ivkhPb{5B>D!u5Lef# z%Bc#6D!Pr@z+tyWuh~&mD3#GvBnvAN%&c{E>+g*p>_?#>Lsgg5)5)1f9DK!c0o5(~ z02ipZzuMT&NrHycaDH2uGv(5%yh_Gnsk8vyPNUnlIA+T|hmz)ADl4PM;NU(d%!293Ga8L#*fb1oJKFgBmz_hSui{ed zw#mK-@t$=&aM5t(TTdc`rIBMN^|mGcQ zx(XhV9g8Ud^e5X3%KedP*(+0$*9v^}#O|1H_FB@=y>xD2jL95IS=l$R9dNEn&1k8b z2_==l8++mT4Ppv8V>abEVm8vG?Sb+mAlNu(HL9+qr4&-bHC?#^sSF}cn}Wlp<9u(G z4apZR@Z&L}&L*ME9vrDs+Nx?A@$cLb)DOlZFC{NzmPK16;ywdz9}p}#l@4FOzCMwm!y7zNze3*3W< zeAZ3OOyh@5R%e>Wt*RABN^>)98B#Vr2aFG!`yD$f^6m(nX7Ex=1d{y3B$5ay7=yTP zV~6=`We6eoX;)h`aV%=JhASFiNGi**W*x7M{#UCFmpMNMwnXYpQI1%czPR@&ZRfTX z=CX;SNx`{q4Dl*g&}MaWQPfl$LN-NdFS+0Ok6rdShD^>VmRy`xin{**h7H3x<3UcZ zn#S>&BbEgLN{#HyN7OCQ9C3WVB5Fq@CCN6y#Tv^1s4&cdl&U1iRCVkQ=GcPF;P|0? zFR~6D%DzrI+N}OMNhS=_I-3~nYc1`*u9%}=@--K<*>+i3QYAB1E78Q&RJ56l?JM3TI4Fbf@yq7P&L0Jrmt z{O(&4y22W6Og`T>|TE)PcXJw_D?;6LZ@-RPRW2O=Ow=MkHw#?m+2mcfTH8l;UffiKnZl zy1G%*$itr@+%UbY7z_BtRx4moOR{<@UL9FJYG2+)0L2SYK!!%}HIPNm+omrpIxLbR ztKxj4FPRdXC#5e4#2VP-)wWnSnO#=kPc`iQaU4{z&^42{W# zs2QpvT2@z{p(;q-wQ9QCVSc#KgB7B_vPP(2DTMVb2x%B0Rb96?@7ovnB*kbSE2es^ z(kIeojs^@>-ot7)y7!nC1p|^8Gcf8Dg|6otBw)Ni94tdZ9GsbR!k$JN51M#iN9qVnvZo zvsy`;kVcZx?hlcFZ#cCiDl8~+45EgiT?~Rp8?u98`8Z*pMY*JvRW@Ck6_`!`01pui7@ga;qB~)_0@)Mr##vMkDOO-cxX)Yp>E{~CBATP& z=~_vpo?@#T767%mY(<8V+w+EL2awE@;q-M8vQ*Uk)NF2HNfS|TJ9OLn;(Z5|nrco8 z$>~{|DrS+}(m|TczItHMi*J;Tkwa31jRlp%>eYlowktsbNP!Vt^fqm-JYtqjjunn+ z)sX13bbGpu{9zLKEMD4Fck8|ys727%&f}+! zc?C>!Nnlr0ns0+b+b5)U&LjT-hpCPt%c)MKU{8tlU{&0>cWZ4h?yWrjtP!lS+G7g*q>}NbR?KwUBooAD5RdU1280X<+tmBn;F$&b{{VbVccG{%Ino$rUSw>Hs#(Je0y~4-7udZrx~(#7(L{A} zP*uo4P}3?qCJnW*tx;2)d@tc#%~D#$jb{WWGM$zkcJrrVPn%)mmDw2{eZ)Tll+6DC zyYn7oK%EIHl1G84b+=37sn3?lret$3guF#Z7>%f7nN*Mh%%qRk5p>Ea6?7a&#M~~- z7HWthP+|gS)CZ6+bN(?mh&+ww4SapfGW3lzEV*mO!JQ6#qzirBIZ#@(;e2aqg>{{XJuP8>(`?=G7SQmNbX z(4M%<9Hi_Vh${XvQ3e*wCS(G^P&SYWJD$MdWsXq?D+Ygy^lV#2Ozg1>+Bi!VKlOWI zXx2tPEYeMNi7Mv3wJ$2$dE24B5yDTRkz*U;EK-#xCa#t{{{TEiKyS_`@yfv|Q2Kv~ zRV@Di!pLf7ZSS>@w`@Ddu{j1O9cI;2Q^vUyQjsE;k<_w<=s^R&d>0BCJ1p~z`-@@DvA+ zmB{u?uO;|+s2Oq$yx*yHEKlC&`(gh8#8efXvQ8$>z87${I*R;EQ}5w^ z=M5hc-$W(kw0Pckl<=>`YUZHG{u0qtGmWH4q!NOAog^szaY^`bNHOvx%++8208?v< zxR89_UmZR~t?F7@s?KJU*4ME=*BoyOj*I+`TRd~)5A1F6E8y)LR_0thYjUym<`fUl zjXmDL75kBId@lg0J3Jb)ouY6a>N_7e+9>1z(E#9^5q*vD@!KOQ2t%RLdLH+~$#E7k zWxhqjd5;j+M@>UcW_RjIAyj!|*kNNAHW|x_?%Wyh@{fe#M`ihp!H^f7lnWblLD+v> zdpNL0D$XpKT$YKrn~L)87^Y{bnN+y+#)j<2z#o42*(9T+LJ7_6@ZKilDxM>(V<>2# zA4EXyZ-0Dwvz?xlaVV6cq3mo*t87L3W1F^gC+JHX-*P?hbOt?CcLVc`VUk+=={7&g zFrLgrMv`oFo`4(^2udo?nmiI}sVb$c*C!jZ2juz7WjT__mU!*ozAFiCgmJUga=O^7 z;z^OiTYW3IAAEIoj#rJv*j-Gn;v$mBmSDlq>0xd5IGaTyI?=G;9MTM{is&;2Xq{=M z=0D7WP>>6Hx?ErN#&Y6~{F$)MziCb;_=S?tWf{~oROwAJ&oIl`gfmFJ7)EcWxY>xn zO*LkAof*T#(dX5*5ydEJAYde2!CT>6jQSZYjjdE2AoV@)%0Nif{6EajTbKdO^pkD+ zb;V-s1?c-T;U^QMkVK|H3EQpk8WESjwB}(?Tl+ZtKuVX>7w&1;o7jsj#l7**IFy0- zw0LVV%;(m$&X9|{&dNd!`vKPt zph%WVw_15-h6Uy{O4kE#Cigg^@?|MkqIT0g4xy-NDC;Dqj+UlaH7;{Xw>xUSCzCUTm>Vr~ehkZFc=X29wC>s# z>=~SqeL#Ptbi`xlCoV0D*b(?r(y?kv$Rt%i#3ig3^V1%bGp4%{Er3`2H_d2dFvqH5 zhi+K}i{ZXS-It`w8qAk9q*C%m%r9@Ck8D~w6Ix^?q6MC^BV!H4yBpl#^Rpy9b2g1n zHCcaLXDee-D9u;UZc71vy#^Uc6KI~FGr!Sq&KLnpn5!QK`(axO33}5g3RqvKxx*#~ zg_5umEI^FxZf@@;yo)$71g&}oBo*BM(iRwu>0%U-OcdU z$4ZGJs{^Aec=Lju!b=ulk73b<_@#)}$&FlXv1}V2hP0sXuHlZ#P8!Lya5rA0f_L+P z`ZQxlpJtVZg1Eve)l!r>hw$e`8!Ve?Ap4HEh?5XJ*aFA!ih)D)YI{Na9SN3>1iQ|X!t4~X1Lmr914HI+#Eh;nWB7+>=v(?OamN zOAOVKQ_C3=N5}sF2($KaS;9jrcLX!gyG3uciT!cU{w6u?Gp%_OU8AMopM&|lEcAR$ zm}LuYlQPN_eTcr;Nq8wMMI+=k%rv|U!*1^Zm?2j3mozdwsMH07h3ejL|EH$0$|CZTF<+bgQ0uZ{gul`R~r ze>Siq*zb=@Kb66eeOfuCj#2bb(^S!Bd3ltu%W4A^GC0<*rsZw+{{T3q4<$*vWYd%M zQ|8~g>QaxLS2I)rr6Hw{_-w*@VJwisAf|>%k}*)akhAw1NE=%hLuoVYwtVI!mIx{1(zhfVF&b&G!oI$)X~o(iJ|8( z(Pv6{4c{{RnsL#UysN-Bcx(Wpk5*KzH?UAp0^NR@Hf z@VCbdzCZrG990D(YFTptV@SoWT@!14&N^^4M5Miu<@_y4OD#PGR$)U+ODX>VjH?p? zZ9P#>xAix~WjZ3|LHQ32Qsy*yjR0q#DCcu&>e?$hwXLXa<73+#GV(aGa>+#Sa4j}d zAex<}&EZp`L|E?8gVF4xxAyCa%gS#^hdX883D)b(>Y-X(wxVj-nvgYE3amE@KpS58 zoN~Dgzhw<4!+MOLG=yf<)oD-@TR|9CWefbru^V>V3qK}t`lK?OHCZ z7apto4!6TOBqLO1GaQ2|&Ly6CA#ARK8;Vz_aU&2nLcs1#t?z_Si8jG0IEOf;$Rx|; z%szK7`XZ;8X=s%7RW{ro^!C48Tjp%KR##=|C(ObkUQ$Nd&9@6|Mp-38{B~*bSdAmp zR5cuu)5!_c;@Vh~>1Ou60+W56c;Q636%_K#S2RY`02`ZoDi$^d-YzlF@_lGC$0xKw zB=J?|W{|}+bc#QXR;0)l+v_A)h1;eh*}&sF*_F;Rn%v_#DMBsGn3$PPn3;NpB<*dx z;l5WLAge+3R0fwks+TmNq0FnL5y8#WL@}`F>TR*@ZkS(@$xzPZjYkmIW>wW|K^9*@ zB{Z7UMGM#=3#*t~`x_0cJK}9RB;e5uc^+q(<@6PIf(p2SQ#DyEO6jmrFS);bEMvrY zFWFm|5e+W3Nk`NNfEN9G;=HOfQO4eYAkJ%R>E+9ovM6kM7#2vOc=1|>}oEc-4%a_eHMKe>?E?>#i)k|f5VB8%xy}IL`Dv3onqUS5gDYJ!k zf~j=L7)g0e>yO3mHerTU7i^t2%>(6hvD3*tYl)high*hP?A^7W$De#r&NL%~F}2?f zAe0 zXclPUjlCiN0Gm;^>20>h9|p8bjTx%^zKW={Qa3gvI+Q4|{{ZQ4(;lCV2NYI44yA)G zf&^Kq<(RJbc@ChY^xGYiT!$va`U7a**xZE!7b`{FajL!^?jD*8I9KZfeD%nkHKeTTpHz>X~x zc^yzCK2cnoyO@YTRH?PT{{XHN;n_ZHxBbIT*?cP)kkl8v>_(+;7O=QJaodjyNM$Py zqTv}iU%``=exYx_fr~{`NE8plKMHFlidN1mO$7%tnKvZ*i2ndju|5Y(cBt0T2`gr% zY@&voTQ8$p3Pl=Yj^ug=OP-{kClQpn6j7~=%Bf0AemZf$xQ3qA7Ay9Y;0e zk!&r?GFeyO-xHvd)6ujl8Do((`bOo3-Y`-%SV}T$A-RlH0QUy|=W%Q?xS&ddm!(3Y z>QF3DvW;v(@G-4|k}POuG}5F=5}28bb8UbAlpfe>R0lsnW+70)Ws>i5Ron{;f1D~p z1U)4glbF<_m~5;<>JR<^#cM{eGAZe%Xz5^B$Zb-(uR=z|{{Y()Xx3Ba{5zayXz{gm zJvBC?=vE@*$v9N(5q1qn!?AGP9=Zv6wJ7@5(x^uN0Ho^a*RjKKDD)jepCt?nCSeT~ z1!T`_!yuS@YAP-d^u<<$u$cIlD~4&2^Kn_HaH2g3x7y3M_rkcN2zZ{6Zv{TfYRg~#V zIabkoYTKZ~sq$@0p#K1564K<^d=f(sC5p%*cC2R7;g08DVQgsRSkt3QS^=)eIC7Qh z)~_$LT(%Ls2Is<+vD}{5$3M?<6-}8M?hvEQUZFCYyucz5rJ4c}4Y!PfZ}}MLl;c)a zJqeWXEiFA(T`gR4@?}Hwa$i`C>*}b!tv2u0_=3!v(5;pssWP0}i=Q5CB}@~( zhNPp27jh3)+TdeGRKp~UtJ7r^wS`SRZlG-+%qpVXdH(=>ETqhmD<@g%t0|$Tp<0<3 zv1o*sSjjsZormd-R)la?T-IgLv@~XXmz_LO5j3=p(u6v@up3(YvBc#YGKxag@NQ0# zy!FwzRot~pn985^4&-9^;!1A1Jd=s!6!r7PmDbHAD7DCAYyG@qxj|7LOw2Dkm`Itw z`=i$ff;S+g%($lP%5kH z9^Ee~HW*F_z>e}v&FXd*`mohOu~$;Dv)jHJ#csz)Vk8+{HMby~FJV%kfB1K2)3V;- zM|>9$*n^cC1U{r=aoGO2jG&ktf~oTwYArhQ+Ip}y9LX6^-s1scLoAn~?<&qXe8nlL z%7iW#(#1^0+V=n(`bUy_;rMY@hOfC{!s>Uf<^dCN-J-_ltOEE1YUdmeaMOg2m3)^;*l{2a97VXr`Ou?J<=K&`D7m z$#hDW4R!1reeskSjzD!^7jp`!nc<_Rr9;?Vt>W0P#wC54399FL%Q4>lEiFGOIsC`J*M{{TrHLHy&~@#DoF zHc2+kWOD^YKK^mn@-)PZ3tC*>p$(FEPyyJs=MDUYZ;5e5#+B4Dt*TDj0>^NC;;ITo zVV02{EaJa1Nh@j`s~t|{-K~moNfYIAv+6&E9CMRo^e|E7%MCO@Z>4=r_dQNHa>mY> zv*<1w;%KX*T{0;oZf}o1P%CEI0S#?CB#M$o;>?Tz3_K8aIE0Z%v*MrH^Y#GCIHNAE z;?IYfd~~_WYMQ4dfN74X?n^{JmHzgW0iQ|HCsVRJ(t`O@ba^ZXVs;t=u_*cak2jZrF@)Q9ygP*B{;6Wm%%^nfjp`uN|{X$3saat^q%6 z3K(O^%x$2HcW#)}VksQn%j);=ag0332h=V*TNuJfu@IM&z3SO|h(!?CigY z^BM_t(p0@6@1XVkV#_5V+*2&7z9(l@G)4&|PG!`I(QN8QGs$FLGWM6^HxO3<%|J50 zaQvLPVrf-~k@(a#b#nQ259T#8vf`r%_xC0V(11Pw|@ko+PB7=&kX(rz?rbitE zOrU>!FDephSEJPUL-vcyxPO+5nNdwCvZz{x+}^-pzFHp~TRk6(emYd~e+kuO#w80- zp=J{9r8e8&9Jw;2j;O+qB!-d-m65q|#N=rxiZuIM?TjN%+JV@WHul)!FULh`G&Vnkbj~Us zEXq_@luIM31o!licHa1t@zFjMQE^Ru*8ctq<`W0vhh!2m}w;9Wh)M zhDwUe^k(_RQiZ9Cw=v5@G%{&LxnOJ$;2xOg%N~0b#=;L6aYaN_RMi$(`2(&xIXQh;V`+kCRd7}1#)mGRIch1;TuS?e4Wxl%()Ks^$2LsT z!>EgqxfxHGdK}(=o`^EjsEm%P2l|D#I2d!~eTf#)uFg1LE1-g&d1$KTrKv#cJPfQ; z?yImE_Az9aayn!7TLG;2f0jucO;0?gX|_n6Jy-Mg9&tsM=4TWOKf;=!BP~4f%8Cj4 z^xEBe;uodSZPu2woh3Qi{7f{Ddm`a=Qk zaBRo}KFevd+83m%Q7mjhHrRpzshxnDpH5m*L(a;qY)mtl$v8d|S z^V(wVO~^xil#ZjmJ&YbUM)woW@;tALP(sg= z(PZ_Ea(JMiq(QJq)ft<}10I%78VM;(=Eas-EzzXmS{k85)5^?#VXhH~-`?kYsyj*R<*`bbTqJhqqjjjM*VQu@6-+tKhEuDP@MjBmT#CKA9>D&(o1xcVaYKBh6 zFhqtjt+n)Qtl770}1T4JfLE2$RkaqW)>@;DY~wszoL4E+bh{v^wuo!YXZ z86ot?EQzQ3Fe>OQ$14lYY@$ zS5ByvjZK-;f^QW>DsTB6{qfJiVtOd9eV3G98u)&&%N}vTloBKK5COm35&m#xpEWKL zqE8f4*i|-Z@Q*s9l)hCaM_Q^3P3jx;^s=AnhF))%9;7s}!inYJzl8inl%*5rvr<(_ zw?0`7$@jkY{NtuSn(`O&^hf+?vJCt7e1?`kp2#al5x78sDcmWwx~lg(Z@xZp^w0FW!&NGG@38c9S-OF_Bc4bx>1Yx$O_ zo@XL7lWkvrBmJ?@Icq?2T>(>OG?dgSEYYcwG-N4a8Hn2KJmbuk-JBU^S~zA4S4%KW zF{7xwP(8M_jlTVG5~gv+PmstfAms9uqh$%pF}oDy@3Fu2!IWH%rrd@{R^`Evtex}&z#gmL%A(7G> zUz2dgS;MsPO_bJBW`b5}a~hL%kPqdJLA}2A^N9SMx;*yVW`ilsrJIB3bGd3^$*Aa@ z(nkm(nyb!~8{5e@>9#!l(R`H=lx$ue_?;d=xt%=-nxYEU-C(*iwYD$cPusBHY)#^o z6O3t<&p4uylP}AcHmQ*6`NV{@l*PWI7N4i7x#)3BZjpPU3f>0H=_ihAI=0Q^C^YjK zk)yukSo>e5*y~e;Q$wc{X~CQ!H8w)Eb-|WK)Om8UtU&a)tEKwmoyICwgG$2aa!K-R zuBH{u;it>0Ur~uByWaQGw)%J9W4;Qj(hNf8L4>q8vsdgm)0I7U` zY;-M<<7K5rN%Pd8M^z0i~Xt6JZDS~Sl1V_&k(fBO-U)l^gEbJfRjrNm)| zs}7)a`<=JLJ}A0L3q+N|IVt3ZShD#*krF~Kqp4lHUwk8!P~Rj`b4d+8Pm$I{lE(7O z4u?9+1}Ag>0J7U#-yFFn)6pl9x1ye(=4dh*(tcbtO(0T0^|`qulYREv-xkM{TO-Nx z*;Siow35@$M-ZGxJ9AykJhjx$uLUB~3aV}?k@Gsp*?vZqB9y})r)`$@ z*phqr2NmNK@6hpzirC7j^BS4unvxZ#N_7S1TM&ubc zX*8DBxDI&8v9nmUS=K$VLN6;wJ# zvEOdLY*+kv$x~$16iN)Tr#DR4<_|Q@K9&L`v|&{2ZMXNpel!im8cHrA%&Btv+FFU~ z5J-eY%2Xt8zN_^IrZjLUbj+c%soIrfr;0i@tCB@F2-;cx=lMX#T8gVWZlgdEBS9Hhwu$wOUJa7#3i z*%QUT)sD!)Bn6<_?1opGMNF8}MW?4C^kU{NDdC+~%O1(36IhSP#;QiJi1;`aiPx4R3Cm+Gi6hUGiSadt z3K}XV5HcZsBEWBR_x}KVJuv#R@{1w=0E=aeC}O^rJ1l!&StGU`M%YxX5zj#R)H2AB ze7;u<<}?gOsbtgYmB`-buk4Sjkf4ivTtod*Qf~=WHUEDm2kEpw$WAS(Bjq9-oXY4*DXU zKt~ctq0sDr^}*s!=*#9AzEe+C^76PY?Vy;{9naf;&JP_L%U)vN}V7-C=0A)UB1j{s(?+hzC zF?M+3Sc;Lgt-a0>=7@==Qprlxa+xb>*`qRVGBZ7#i-@XfsJ>D}bmk2yH5t%RPe63}?||g5u(hJ=FBKFGM>O%o)cRR8 zR3?%@8}-~@gn7u)Yu#JwXp~~RM-@6VH`0|YI16s z0hQoFAVt(9V8^Fhl~50V#vv+CvvkVEshXMzAdwm-M%AGl?AF`g0nNXyl>Ue!%&S^y zk0Yj~`3`(^%e0Z9GQYdq7sndx$#U$(zF{`C z4^GGdvjW@ui{qi|V#+B5O9B=(6wJ>^;{O1|BItXm_r$rnCd&DYnu{m`$7^-PqitIi zY*m1;AcCj1tP8P;<$+^}`bF*h*ksx<0#=|vw`V;pFztegjLHybQ_Sozfan@=P|{uF zA&~SS0fLJF zFk7@ylf@jHG_1%v?c)m4YJ}xM@hZT@qmlR6ki;Lh*a`^T!lAC6S4n+HM_1nu#*NGr z#0xf%pdHBr29SFiBjsMiSdQ2xAe9y41SupP@U2)G97r_*xF^O3Ks_hnHgwcdRAsW8 zDLU7Ex9g8z2S*lElhN!DwT034=q=wCZ(?!KQp;kbp-uW7@A<~E6xgO9va!+hU&7yuq4cD#LknCn>xj-8 zvF!S9hPcj}Nkj)GkO(Kq5 za8ks&K-dLe1IF0&l8jNqHzxFWryl%Zc~*K1n2j2W8kDiy%KreqIp?2RJFw#R&nA)G zq<3jGvzwOOl6}rR*~!VBkUbdeI)fDM3KeIRUb)?u$xAY!FX{XAP6vkWL4TUwwVO|huMk|>>SBsUuo zZH53+vAn$>%t-J?03`UG%~A*}r2F8dM!O+)j==0svB7M_Z5SrjC%y%kKPTag&pmcD z6p~aT5FM0km-28q86#sw@HdF3O>(t0F#r}1CaYiVfhi)DWfZr|iwvJQ zmnWzWs3nO10L+QHIK^W96PArqN0R4fnH-53>SCDaW%dWS!|_6?I_OHOY?~uxk>!q8 z{#c=HY<}mr-v%+K*{!`%mCY-gHLf)>B9BN#Udn*%2kU{7b)ck?0-`;aLJ$q?K-l6O zpJn4*c8@^#L&9yu{9i(?61_Dm3W?iKK&IpKa6e2!Q)Y})+4c1_(h;Lb4PfoI>JMY% z9MgP?#+a{If|+IIGOHe%Y(@(Kt!AL;~l#N~>@(jgxWc$+7p3zO$`>7=#eWM8D(;1Vytf^iq)C)p5?bd^8T*VAu4_+^1dp?IbdnDM4{OIZ~Wp^iADQyeJwC77E5&|P=bC<}-vJXcw?#xd2Ho(Ith%zE8jRLDXl01C z)wm>u zI+)(xF#Q3dn~1X6vl?}p2@F;6H!>NCHwU;rRQSSOm8wH{V~m$JGD9YqYhfiNj2`}1 z$icQFG{UPUCBM_S``-hQQlv*y zNj)f!P#10R9OzCYObH=QrN4{`N`b_n&v-V2KdOeNp`B)c6jqGyV`F3b3@6J)Vz`3W z~}m zbO~F+*<{Nsk$W%1MG@XJ$2DHW>PCW&NS zE-Wld41J6z@ztErlZqc#JW8>wX&=qhHRD+0^$$0;*nF-nZHqjKY{};N)=^cP%S}>_ ziB10iFH;>6zj6m-k1sZNi%D6-EVZyYs%i?!ndFt@60Mqx;+5(mvZ!lrzE})*Lb_*mI$=}gZ(UTf zQcWS9SxMEUgD*=Fj_i1&+B%$2Y+|MgWai9i)Eg{G8rb>1*Z#QZa7-K#b5SfYQ%~}> z!&bYrIxovNy@k%?57QhF@(`1iGbzVBMLubpQ3IIPQq7eEs$ZxGn#F)Uuj30Wia~o; zS~hwcFQ%tylA@FWRU@_S%k2F(B<*ZMGqy*cpd5mN8TgtysAHX|r)FuZBv3R9YyjydW<0qap^X@T7#os5^4R6^^R>1o9a#GA2e19rT~hRs z(ksehjU7~&K)ZRjt6%^fap}(@bi`<<$bJ~-Iek4gWt0B^5~h|hEmZ8Gsi1N{3*QqLE0xl~vtT9l^xr^`TUG1XRn!^YiMn zEWP8UPvR?7XoSbT)Fp{5Kj|YJ-(*YUY0)iZ9C@{J$(T`mF*BY#2dW8=0tazRB{jyg6FqX5-a#EnH^&Oex;UPh9&eS^X1QE((@j@BRe%uF8;7_0y8+-~lWCn;)Z8@$ zv_H9_mO7xJ<)~tgj1K4D?0RFlV{=8P(P3Ad*B_N^zBr|qouO7_)pQ%`Yj(Zud@J$U z&fw$?nP<7RRQZhAv4#qWRT2tpx|u{y3Eap@xW8*(0)9JDO_hc^TLP})iJBJ*hK8sR z!%$X0<9n4Or%kXUi|e6ey%gESZFXrSO;u4O<7_pN;(n&oQ$F00$%f{si zY)mn7GIdb8>M)|iBDiF5fZPt|`1PZaG0q@%l z87{`9=p5yliHI2!LbEVKBWYG3^as7MPn8;j^3ENks-&vbJ1$`vvP8-Ct-VJ6-{%*3 zqb(v#tr=}(62@bP<(v?qmG8Hbd*ek|61H5?aAtp)6p+C)#iY7O7kLHxZ`bXN;Kt%> zGVh0(<#ZDyxnPQ+2B@kfm_^I-0t@QC8-UzNrub*XwVsf%iBW^BsZtbzKOfT+P^Dr$ z5l!%$F>vy=T@+Ht*L7DS{z*Ls7lQ0%BodqlpHomkij;NbT!mPHDyVyg1a$Cl)E6&B zMOOso^r;I}Qp=`S2=5y6E$^jzVu=XXvwOpwJCkIIs;aU&nU0l)85G7({{TvQ<0Z0- zqf<-r4{*{$7#j$Q15PaZCKU4Js{DtkiKlU8QzxmH?TIp|9$b={q`25#${me|{jh4l z4<`=MOUjVW(Kr@lR3-YWV~qMAk$?M_F3Ga^ zs;TFtl1TwC0+X&b1EYW23Qg>-rKg-SG|f!N_i&WxL0k4D;DDO8o|-x~Y3zxhsU+C$ zdmlJ!Mj4jnutt>pm020hkY4=8?4`VSz8Nb6dJCShi%UrG%3&lKUOkfb-9i5VNcP2Q zkRr%(X=$UIGNy%~f@d+z5txZ2U!;-#pf(ojFNIqeGfuEaFfhK_F`5cM*{x($6wM=+ z01J|$_P1}j!h-0kmx$@aa7@*!LnMR{Btdo_EKTtCj6S1_a)zCeYZsV|3r7*uN8AqB zSx`_0Y4JxXp@kkLl5*jStXmUr0QJHIsipXxm}V*_hbI9YP0aEY1P>P&obpg882m?U z#M7jLI(Ghbj_+aYMYsFnv6mzp2&m#(Dw$E|{pBobqf6X>p7ROGdvkp^hqCv6)oKDU$T@*lBaQ3_;vqez@`8cNI)x zuA_-2qM037jZt!*3xj>SF}D8zd`2pAZHp-KD<;gUoeavHw9#dzj1#4|JF&4RzAUjx zl8z^2u~$^qQtFXu%7)RXp;E@zxfeKu@yZ8Mh$s9)W>G<19*BTbB67`$z3gw;;gXYx z?m8?o`Z{Tzt>~bCn1)#7i%ImlmLlVAt&VBVP$K4{Nbt2yUW#&Ez&fO#)C*tKE!x-| z+?ARyp2kpR)o)ia)zj0$2dKGV-jTT56iKu@R9?YQVUbccj(|?OL&gHDjV9M46L{NX zeS=a@PgRtF$m>-T0V6sPbdG>utFzKihE0%j;%6q~Ip_<^Lrjvg>E;%=Mg2PC zt{B=Y8QD=!4-@h1+=@slYS-)25@}UmzQe9MRBK|hTafl4`o_*FlZ%DWxbm zi+#Wzeelj-Qc^tEGRX3r%jaa_W|+~$>VlSO43jYb08-oP{{R?BKd~tpvrSbD%(5ni zLt?C@Tk;6UcX|~Z{K9VE^1-s(Xue_Q9c$3&3?; z17Y0uzzZf#L9Kqf4YtNanZT4|s1E({RD~MFwqQUWFM%yEp;lm|2EVu+@S~w!?w{?9 z6QNV2i)=jO0f@j0ka~3kz7G*Y@=U|`R$)y#l^R=n@3HHAbmE<8hDB$*{yEi+>o8Tdtv%SUcwQM!%5%1GM3Az{X!y@Lz5e7 zVf6uqu^x-OlQ^3$s1rnN%0p=fV}SO7X5TRQhnZ)T$xSrOw2CdsLO^eFJK>`bVmau7 znyJ~z0KK~&pKNrb=$)~ZS#3|Ij5tD z21SUQN~CN_@8a0GdeNH~}2861OK& zzn+)|8f8>%CvtZH;8}}&w}o@8;M#{Rte*DzW6~|=?O;dR_}r*9t2Nngz}_j%X=JIM zooJ(rs?R5^{ghmsMdjGa9F106`#Cb$*XFFUXw;Fz7_m3p9b1cGzERdQ6Y)ENa;^(_ zDWJ?GnzhL-PS!R9y~j*EWyo2_iH*tldos`JTAwYXmaE-{f))P>*EO3^id#aej{-`AtpTPse?I`g23JToyUAl!J+*bo*>O?_=hkx zb<8B3s6xO1NCchj_c&!1O_zKX@gFkaM5vC2I%1U@NGf61t8ci)P{_~m7HJM|noU;) z926@l)M2IsAU((jrOx)oF4I1V0~jmaR6fRkW<80D1sIxmhKk@SDVkAhie0Z}v*@Xu7z zx2|fH1&`j_4`GQsmUMhnYUklvICYt6?$Qez0&TZLZk;+~mD$w@tK7~MQnv2ng@$XRZZE$gJ8Z^*eFW@q|GVv(O4x8YfVGC!~ria`bZY>Z_@;t z?6u1ldP*2#mD|?E*-5z6P5%J%?Ti;;=_@E`!;LIDw%}s`0Uze|)3byb}qD3qD0RI479U_8N)#d@*{GBaKWMBAF6>hyWoxFGNjcJI^ zTKSd|8!f3)*J6MM<{$mQ+x5cr*vSpcGSfXol@-ksu~MlTl6fob?tI|#Of3^v+M7s@F zBTHQF3fy99TwRfh;_Qkn^@epzSi$L|rDbSngWML=q`BVLw|=|gvGR9ETy}19pNKKn z%@VRGXKPF18KAR%ACbwCI_R2Lt@fubJ%Te=ieO)ccT|nHF8v- zEb~U3#^tP_EsuSV`NLQ!5@SuvmO8TYvNhLSYi2#|VYtFMQw0Od!#PV-PV&(I01Sbl zfdNg2P%%XyP$O`TMKLmoWTzcDYQUT_kT{w8?i8k_XSGuU+DQ+j?S9y2I!5^HqRe2X z${k^-ovEJU#!=`X^g6tI;%hF=C{ih^_-8K4b0MRm>4*7H8VPLCDUb10 zI^!j^*KX(x|ZRxpi&U!XqN9FS--EYIaxMV(|f*@sQAECDsY5za-H$nv8y zD7!wALjEww25kI#r>P^BWr{#-vGT>dV+66u__|IfrD~)}B07qOk%8&dkTJ~Vu+Uka zYKh5LJh=K8&(;rn95ax~5N0{LQ&aNaRC;W6p}wyG_ZP&QD56qF#_>k+^9p@N@r5@h zvhUN*IkINrNV<=RDe6pWD$6fxuKGukFcxbwk#9|utzA?VD-Sb8%x`;{2et zVBx_@Nbw>_0hgFjrYs9z>HwaC1tY;-fg+*^B zXGB*+*ab@{~Nbd|UB7)au z7ub31aW@DjpaVpr9Z*LE=oZbSxM9$2FdL^qNJg)xtvtZV6wChr(B>YcvA5d>4JkMM z4@I{D)8!NKZe12)bV4Ur*bANZ9@ods{%jMI&i(C?Rj#1t3S)4rmduks+1@S zk|<$oZP)x``MOy$S>tOHmP^rfkN!l%mH1YY%?lc^LL%ha9cZ1<9h- zxQS~ik_x&b0v8GumcSmHk+AVqDuOFgEO51LLibRVe;(6Y9D^$_BOuQ z;>(uhM+~KFM7eJf)=!ElrxVh>3wHz$38H^-UfW|UdyO|ZQ0Ez9#N_MRmw zkGsa;1t$LhSGo5%=9YeS5G3SeGi=T#Sf-;{AdZl?G|q*M!LbF0(zZJsdN9Mw9}>S6 zD=+1mrKtY^c2>l4scD#c1ZwV8mg@KZZM&20j^7{0c(lVDc0VHFG|XYS%r!Obsx-3_ zI`!Wkhr?{?jA+)um8?jNl}i)-E6f0~KVjGGaodg#3ujb%6jDW7A1l z#wt0IZWpg?vW|EnEFPVsJk!c(W+LV`{`c>Xo|p7_u6)^4a$0&QDwj2;YT4QqH2Nh7 z1l`29J+|qBqi0%QQVt%LzMC?V4tAp~L`diPh4)MN#U=Ds4vnQfHd8@CJw-KjOF<%O zhMcfwiczx$@T7FUICDwO9MY6*w*Ac=0aw zf2(|V;_>*$XIqyoi<*2MuBJ%Ibefq^Ms!#=UBMs^*Bx+zL#a_yH^Va?S?Qd|Dzkc2 z?8C6R8;j%4&6VSoB3Ux*mxulx=K-mz>4hpthf!*YO6$JbZQNqA$MQumN%Ba%sNl-% zwuxevN@l5c^%$nMj;Cese;u*sOUL5QNkOu{whEd&o+u#EBvXq^BF0dtz3ff?p^iy6 zU`@oAG2z&=Iyh>iMv|g9mrB4j8(8k&e)#l!d9~To1m4Qp*z%DLBs80CboMNE%1p;SqLNtBoI-*zvvuDVl;X?K*sG0U2H~e=BhtEW?0vBr z&D9`K+FCjJX&hroB*-+W)v&evVo=7|=$0CKWd<2$^~k|=fpPcS7LF!4X;BJNh7=M@ z&s8Yx04ji6aD4v&Y+K@DNG~tSCCqB6mPr+2vhvD5OL)ISisSL@Q*j@{5nio4wQm!$ zmz7m_Z~AZ0?c*Jv7_?qx-wyI@vO5|>TOsHsYuI)J#u-9^Ma+~{5knj_u_Zbx*es`7 zk6~_@ZYBX4CS@`fsmxg{Z=yEb3{qVTSiwUbGdM{lb_`vap7>O(3`xTJw8tMTjornE zvA!FKI}3)Dd1?}6j7Ywr16%EXI8{+#;zA%4l*I)4bb?gLv2)tzzuyksltor;ozX;y z^3$u%K-6KhhgG++J-lHoFJM*lw3(bC+K?F;c9Kan>A!qy^eq_N%Q8GBTAx~?#b$}r z1FHRte_TzfAE0S|BAWD?mMJURU7g5VBCmbV_`|sv7b~aBxPw2Z8MS3iEf$hwsfk*5 z2G_ViN81SGGFAgq#kKq|TG3G%XQvFw45Ss-x7*XX8+E|s9ww@bjB}jDA$U?Yr<2vK z_aOLf_rr4;z|iIVLzumzl32k)4w$31tNW9JrDWV_(bq{`Nd#5Z4zbb}2=i39)U0|7 zFK>J>21KaKeJ;c51d+Y^jlK85<6$6>S4CJ}8mPhpWr9W8+jkxM;5dowD8$t|qpMY7 ziE`RMhimlrI0+45;;Z*<9-3%vsylM*3q&q`H~#=va&c4!1k=o7r(nRjTj)`JBh9ct zRA#i2*UGarsIo!|>M4Cnf458vFv?+?RYvPgF^*t8Z4wP6dtZDjm1t$qT5$D!bu#?r zX)+^RZTP_B$W~Ej95u^~t4qwQAlRwaK^xoj!zw{c4~F=BWsw?|p%B%nAck|(vFqOw zlHHU{rs6&&dF#0{Wz!Is(h)#LKl_htGtv#2`Ub0>XKIYSV2L$_m1QjYPxAi&?Y`LK z$n2X$&_hzONb%Ao3tGY9C9c3;=KX&b!$InWirLa-vec@I{MMqWgWfpdVhJ|xe_T`# zvcej=9M)KpqI#5xN}yCi&g=(G`iw73CDjH|QI^XcPE}6z&m#iS$rmjJx>>)*1h2F( zbzXg+QPjJB=|a+v`Dib1^)34SjybMm99wo~xUQmH;QWG zDak5j+*z$MN|gq9!jIvgVA_w4xaO-7 zyDcm7x(e8g!Jd|`S5jGaSin#$2i#ug4;gV41jUljzF-7ZeE21~vh+X(>_P8_myziP z=#1sDg?V78mS7u{t2j^}$v!s3f5@>pP+HO%9+NMb7JR^1#VUg)qx`7Hq1yJumRgWp z`6>yYTnit}(o{l%cGdUvdKJ>Y$b8a0FNVk zo&MLsNyX6VP})4jVMz@6Y+pBK9OQ6Ng5OE(cJJ+uh}dYb{pFYCf++{_s!I-CBv6tg zBpctgvDFsQsHR-PN{Od>khJg%h~z=n*{$CRkv8lBiJ8(><*gL7Da+M$C~QYyeeb{8 z_@+BgWf5Ntl=Do?q{y)_2(I5&-N*UEWT`MR%7{f!tdY{Rvb$?ldCG;-ZUy>b)GcU~ zyCRAXbdMCKIzm*vgBy@Kja{(t#>&Phsn7DXsi&w#s(KRMxathyl~i`pciSCFG{HJN zb3EZHe4?#`=V@OdHZnnGLw)-H0OhgU89F={K^LJuv)I5wOg+F>Ib?k_LKd zfb_{3(!quq=`4xCZ9kZH0R<-e6W@UA6SLY%Lf@CG34f z4>;Cg;ISbrstR)FB%%w|qKg zA^EVX3XyLg;|~`?u8&ywVZ;Kek*Oy2Nd=C>s*|xl+a8W7-)9C$)3eiJa>Q9}ak%?- z#oo!2M`*~kh58F%BP0~86S*J@eeptxj)@dA8*V)H#uc!Ln6}`Qy@9d9`w+X!>m=2< z>-^pEMC)QDZjYjV1n`bUQedvlX{D{0+^jAMjeg_5=Mu?~e~y{<9}g~DB??6q3=u>> z`X41gx7yhArzd6Nd}IFr)g}F&vTC1)@NxD@LmdrvT`-EeI&{*K#UZeJb}HTc6OKtX zbw#7{-lis|BoYgQ(-K9&T0qC37VGXX;Ubb<&YM_%qXfiuXCqIj^}rCe%eY%O&1Oic z=x2RrN|ubGlm7s?+x5Y;yD_WDehP6#X(mWuqmTVl%s*QT?TNX>bdA1I`#A!S`^z_3 z9#8^&qMHML84;S%;mTE!x^=88);Eo*O zx79_J(Ja6g4>DMi4YwzI`{G|Ckh}|u+~+H5=t3A^*@=iurI&8Kz3~~z*+i)nQ2b8e zEV?I(T-rKmld8(sI<2y?9S^=VV%WVi51;&c%jq(yS1f@u490lbeR`2$X6i?uV~Z#> zHzUBS>uR$~x2dalsh&f2B$CIs++(6DiBIg$M&XVpIc`8Q{I7K5vG-S+CGLaMoZ@ID?se?2HMv5#`ks;j1eGFd&8HRi-a{7@y zC1$y`$t1v*Wjm<`_90JB{cuz$c}~w&;cEEkv)slCnFB1bnLudzkVVM++x%df!}#7) zN|9zP!DzV*9f{p{+oxBo8~-)%EX|7VzvrB zu*`^qne%G!v|*P1y<3mQ6WN7on97HB-aGocf_#1PXVHa>877ZOx{s>kb^UONVr?qU z%A_e>z}2|+_r?$j!Hsno#^i-4Zr1n42viLt8v|f=0G_y6bSmtXbU9_!W?sE)PjBmm zh-5k`C4ov7wb&LGxF`GKfI^uXqHC}lbZ_u*uS}s1srjl@AOQNA#m1jvI-F+gnj^B&{*gMog8^sLLgs7L%5{BLO+yUPLiIC4ma};_>7(6;`Rztb=#-Y)h zt@u}vR604z+nS`5mN^IrdyS3oyetkj37LE$qt2_LsFO6!<&HH}SZ1g)=(j+H$tpd% zVI_%C2LN{XQym^<4McgY)e8)QO*6!|fBIXuTyuOI87eifWjPgISj@D>inmqt#HCe< zJDoPSUH0jUJ4=Y_euvG%q9~w-j;=Y_jo92={{X9R?T(B~R8sT-K1rEnbdO$HV0ffm zQ3ttjdXawHefPslLfAHIoi<@(PgN~En-*jjQ0CiiI&}uvigxT*v_k?_7gl`3nG+JH z)(Ew~)7T6%chIp#wJddFl4{qOG%2bzhgebw0^X22f^2=Uo>yZN(s2Y+&`MUF=a2wZ zB|xU#4ej3kF#iB9jH7I;s;$dvQlbi~UScwhQn=Np{j6}m$g^4~V~&=eGL0xHB&w0o zxoHXBLOTQY{NT9B95ZyvxT~`|@(fe~-%go?vD}akUAo)8B=SlvaW$zCInETAgJqiw83{{UP;WTLGmL!4x* zUrAF>3DeF-RSdw35#QSvjI9%Dk2hb2HLyI4VG{(lsTA$MOcudL?;v_EAEt*ckzi?~ zyE#qSS%|Sd*o$LDQK^;GJZ}O9X93QYu|IEYBWsC90De}gC1#}@_{p%i1$!Qt4{-rr z{5h7@&IXvHopmV+Zdpj^d*2b9Y!Zmt4hG5LiZ)3qHWqafYV}`!yPQwru<@i`(pSep zL8g`oCDVH*ptte%#qP8!R6{*M%wp#$l2dIUlciI=><#^~Si40DDfnkC%%)iC(L%Ww zz1`VwaG;&GJK}PcGgX1sW(Of0i*u!o+d>5_R9O8@+xvUrmi97;7Ei|%a@3kisS=v6 z)=x8F!rfGN{{X%vESzK-qf?gG(`GQqJb%T}ZP|2y2XSxwI6p1u!{@0)M35|ehh@@K z?APyZ*hea1vX?Z?@_H7M8mZ%rT>U_R;PqRB)DwisDqM-mK|DG8wy!tHswr>Fl4XsK zk~KJMkT2kO$IpICH_3ua`epFTX#3xW=qJpnVUQ~bLV%{$7Pdd1bK&Iv$JD}RgD|Pf z@;X+UuCf|vlwF=y0BzR|hr*s$#|qdbkwp1(V1wsO<3ts=JK+* z;@e~B@nUHm=}@gsja5BeWRp&H6#f;Q7q-Ku!@0+A3TC3uE2pWYkhD^`L!<^)(g5DW z&9944iBWe+T=n$(Q@_kddp@Mw&Bs%UL}Ah@OoyCwHNt~)sNu|FvTWik$_WBh$v^Xm zURwoV2`WK82m52>{>_{#8$#we?A%mgiJ*;=B`+O0fDswDa!rriW3mvE+0~6nc0VHF zT>hG&X|+QQ4OB)+S=zuT=*70V>**Mz+M1xtWu;#aLoGVy6xqYmPX{m299qPORe`Yj zuf4`42q``%H^&yp-h#J);*PRB!Wyi$va3;rNdR4}NKN(zZO$<@rTo!Sj@@lG1++N=rb_``+veY%k*2 z_3=r5^mM5vi+UQGg{FyRdRm7np-i5YC#{GFU`9E-oT(i1bel1?HPuy>)q*)pQ;GDf z5Iv%aLG8BtcgLLu`CXi`ZM$Z&kBwmAJhrk13sIVwjI5GOUCW+>*kjy|Whm(Hgp<)E zKN4S5MzR4-Qpx-%UO-kwZ_jUha{TV-GE`A1K$(tDS)EtK$a5^rKv>gfV|~A0H^o*v6-C){p9$+;mKo}yRc9o;amlJd?A!kU zY-ftYDn#w@;<~IYByp`RF*m%#sr@&(7!MR`g^FE|gW%m|H9%>iGDIKO$_jQp&Hn(l z5qR+_WrkP5)wxYmveLyQ2Vu_A4T0!wz9_IoA$^ckWLb`BT=e{?p;s66DY0Anh5Q0~ zVb(PI9R!bs?F~XqYSIXi{b>LLdu@MgI)Xv6{+EQQDI*HCD>tg@k`9N*z6*+C$gr%) zp~}is7@$_=s&k`oii{5X9{36I62oGTIAD_rgC(xJ`X2r9U9t2XNl7;`T1Em@VpSjo zK_vY<;lGbyXgEnMHGGL;FsM&acl85*7%8SN5DdpXk0x0jS=B=9q>vi+?|~&~CUks9 zqs=CG;Ae?+YLZ4@PqOXTe)#5=MFp{BtrUDsnM<31G|a?}HqwT?Q(R z4o9DnPBkQ`ytEOz`Z;ayx2x@kac`o9HgQv!<$1eF1yPnK4Xfs7(-;T6ynACL(%CY- zGx{p@mQzERR6?)GdWuy-j(dO!y}j*#Iz_?Ds%z+V(`C@Yi=;x8PiE8KSBwhXh3L&y z#UQOyG!RD7Si%LI7xxzFhm*2qn=IklY~Hqdr&wc=s-l1>{d*2grpj`!y9m*oD`HGuL&2YNyWl%Z*KfW?an~?@#mgN-^D~O##A5y|? zZ*kaTQ2fNC;aVzMfmIxpjBG%PNpGMYoA>+UB|_bYRAui;Wh*Z`P}9pgok8hy(%*~` zIc|w*+E%Don&Cq9aBc66Y;k6$YO1BDkN8fY5iP7gH}U5TlVsRUZfBw>X+b&-j-@`J zMgZ|Z4!^~S_aNI2l>*4Ab7K%Js^Nv~NwMFlznli>HV-afg+Nl{R`)IaFN1avdU@j$ zN@bOVl3R8cTMus7N-=4c=9I9skr|@&+};%=`(Fzn*)C<6qSLd&+R0x{h5cV_GM0eM z^%V0|Qz$eOOFVC>+HJXm{a5TRdSixJ9g^itjByaAc%!JI`7t85o!hDE} zmc_2iCe9X;h6+@nXHw}|sGS6RFP_`rPHHi+tji3qJc~DxD!78KHKl7WD0MypormWO zk0P3+6+cC?@n&HJ^TJ$n$+|g&o?`cHSGC8sD(A%%O;Gy!32U<0Qm-=s9j_6x>c3NP zM@{iKNl&o=C8g(9!2~&+ZuJD-rbPFT%xBCar&d>5Sv4$xp<>n_QQNP+DgHQUw8-Z$1d5X|h2AM6Fg-%FPRvF0 z0CyvM0zL5+wf+a8C+p3A|nWo33rn@LWF zdQ#3dj=&J7+zfAm-I=vyjh5yuN){?uVAHtP%BI%dRnXv)F@+R+^zbX_P#IhBU&=`Tyes5KgL?=b4F*?B^t^p%P|a&1 z5hp61B)GaMxcd{1kA^YQ6XZhM}2fd2X36Gk}Nw7W6GVDtpkpyz9y^i-g zV6-|HpCW;6$7|qK3?<#J%(nK!S%iDW+kZDwdYlUuhBFet7C&oXrfMS|qCjRp`>;(! zh|DFrjji(pXDk!FkCTH`3NH9pIsM0+K~Z)nY_ckwTw|jQsk(z_T#eS5oe_J~6Dp zl+I9sNwu)odKJa3p4ISci_H}ALe6$Rt^WYF5>P1_e$TNuGd)_GSk3y3a!xclA^7RT zuyNPHt})1_0n)cBo-tv#V1%h3VlR$KBwj9$!2HHmXIEfVokKA2NCb_%UmUeZWq>rK ziynszYY<7Q;Nu#^S>7u$HHbI9Fs7p{_?5(YYR0kVk~~N(Bb7s_AEpCJU4hR5~2@IERVnhK=j zE+OI?Xz1qST1o&2A}Lo%BhIUJ@4gkmF3ruF?6cvmPH#x^)N#c{Nfrh;B?X;M#!w}~@YC}|g)BQU$R%A=*p@G#P-h?Sp9@TUP#aHdo#>DDT$)gHQr zL3eUH+;qo0vRlz*jrM9xs|-YFSfd2#)nKR(lWvFK3fqwJF`P;9e=XsN%rU>uR%kbh zh=R8t%3GlO;g$Op?D8HY_>sgMU0RUB&qou2q6%P3Fg=MIoK})1%RGnRUU!)vnan~_ z)7Ueny;6klas0dYINYnFRi3wz{5Q&S7$RzV2$n=Y^Ge;C`&^UX3i4P~3#q790{qC@ zSql<{ItzIi=asUQs*oI0C4G5@WYaWfnaE_*W$AV7P5WV^Xqfu^ovSKRZDrF|y*ATg z1*}I)dt*5^=xU@4ICmqctc_)(q!Wn9Sj1~{<8J=|d`+idyGM(0pTJD*^E%4PR-jao zi=+UU!g~t?j)=;TlxO7lbH=$pDkGCkQn3(u)Q++R@Ov9yy|Da(qwLvm_YrZ|snQ zw*DtE!1`CA#%jg)WK%@0_X%Pzbq3w7fRzR8Q1vL+Fd0sD@Gq^MvdTGHCS#Kv}@KK9j%w zuzE7vqG=M6F{#+Tq5wAa1NOqDv84@I$>66YG;XDMAxLMO0Lkw4RHp2VhT4 z_r4ZUu7*!Vg4aPc6DDAR5t!{HO50oMxE&9+B%O8@qN(^(BxzBSS*RZR(nw|^$LvkN z7R7ie0qCupgQ-@oNvU%wqOFS3uBiF3z4o|Jd~R@Bj8?`@fOvJEIFh;vB3Tv(WqG2q zvFU9pcOzrh8WU1_KIuKe_K^UU6#^_79`C1DxoRr1)WK-fBH?jjCtAS+f*xH6%U#u5>kn2 z4KlYdh9j=PZ`2cx%roU0V6pK>&yp#bRptoA#A5nF^d$Eke@qEW+cQm$ucvR_?KM37 z=3qof)>lP6ZfrIuxy2(S(9}g+mu49i6$W8gSjAG8RvRmyAou?OwhvolwPAD{Fi`sX+K8o=G@FzNuxr>U?Qg$aMaf>k)dS{rIgx{s%(Gb9 zNm%N&#wg^P(Uh1bU&FL1dV@sDS^m8p&fAiD8+61LmdF0fi0ZPs45G9lr;0dl&Wy>T z*XyL;)OYEGm-H)TR|saAeRBMjOVq&(aO#D}saRjV{f|z#lx4bP)UAZq@Mcw<)EdgA zd56&u2HHTikFm#ep~^NEC3P=}9FcLoFl2RGU;82B6*u`}Q8#@cg{5BB-;Pb5BUlaYa$gX3Obb zv{U7@a)TQf_1GS)Pmk8v@~}Cn@Ovi}%SC2H`GsWFaUp`bf->*(9N-s7C;5DweILNm zRtF0#ay-V5Juh@X;*vU6ksWGNQRq=vh>vR+q9t$GohN)dL&tk2qN9>FMgA1Ys1os$W(TdW{{Vvk z&u3NTGD)1f)55C>=nEZ}#;*8ograU#G^rOUiIU`vF5a8t0?g^C$ulGrGt-Q|IzZ+& zWg}CYe=zDtzrH**j-JI%MJ8QL#--wlCUS1d>fu2jo|x}c(Mx{IS{@;I^1f9~Wk)?h zRi%_`(6`%8*T37YIda0bj(Mi~E@>!fvaHUaq=qOd;Yoz3*8)RpSRL*+?cW^yTG)#m zis?9$EzRm=Z^bQb(IqLzq-YM2{LZm^7=c*!64Ms{OG@Vv&|A4$gDQ zvwCHWQwSpmQ@uO_G$*}}TVt*m<;sqTLbg=Wz=7jI8?y`9$kc3iBl2-*;c8aLapY+- z?h4IoVlvXwffxad%ycKXvELm^8qic|(b9ZAuBnX$T**li4@thRVe#y7qZ)3;?6Y5l z^wkVrTFH#7U}T9vEI;$6DZw*QZ%6RMD1kYR46~~GfRU|j`jd)qNLw$Ur_1Q5*NEqdb?gq^aFR(IvM3{5kaGgXBPanCRaf*UwiOzf4PJb6A@bB|5*1(KfSafP08OyA zFv(e%dRghSWfZl`G*`L4pc~HJtZ|Ih7V>eB%BU?mxN{}6M7p&e+x|P@(?BXGbMq^YUUvYke3jjBwh7XC< zG}NeTa`_EXNL0p%JznD7aO|40&JT-Ocg{@&lu}2b4V+unK-?%Deesh>W=S8!43?&- zEYzZ&IKVn;A_u6rBfkFtY&|9dEXU%uTS&npjpU3qiviQ@JL5NFSu*@r$wZ(Zn7iB5 z!rDiZ;NopG6a$#?O*7W4G*wd4tG7Wo2GdEgoAYs*u56N{+zy*mU;B;%6mhLYId)f}&-b zO8DUs?!JoJYN4@;xL$H<hGL16^PTqe#@U&|7a?4~!M_D9hI!Y~?Ph;ZPQj4J6!ms2Y5IoS$ zP*3qpV*Ba^P_!=?p-fl@${Dy;46Ct~*(@G!o` z_AZL4=RqC4BHpp2U-5=Rgr-?EsxH@OBw9c}rWU|P*=A#xjbY#fjXSwegU`7=Fl;CT zH*DQ#uJU}e1|nI6U|;^7U5}4A=9W~1b4aAi>oY1mzM76IdczPx$n!p{Zb{dD?QC;N z*i>(2)@Kwsj!@B5(=143S!HwuWGV+h=X)GJIW*`u=&GCH_YJ)pLr+gAj6?{I3ACsm z>Nozl@4H4b^3!EGWo%KyJk*rY#t@WX<+m2LpVxeG%1$hQK^fL-m(k`hRMMqYbemot zZJohAbzFX!vZ+KyACl))Ij&(*sLYYXrJ*%81h-2ix*hS%)iP;YE3*vmJE)D6)QGve zM2;N_ZY;nbt8UnyPqL(2i7j4vS56|8vr0(n0lc*nt;~!+={!vkxGvIq$u?V`aqhY$feBdmB^J&n-1IGSo9K%hfW&Bz6Sdudu&n@8c22 z2}eyC6cv9JIA(~(WTT~(M?Df^$c zI#wpPLOCLfHu&!t4Hikmv(VUS=2T3if!qMMAFduaY@1~bcgEVs&7sWBQ3cJ{+)+anpH z1UgG8?mG-JqY3j)#dZYv#&pa$RfSd(5-t3yaH=#TLOx`z7*JaG8=M!iY>C7PAt3t5 z=uX&lj7YGM!I%r%ZsQDAB(b4egT4a?u?$S_U=QO86OkCUkgN}zVa#y!?%K8+;G+s9 z4RSX7;4=+L5Sv(^z6$73=H&0!u$?#yGd9uKo@Qh7bY2q;0tvV;#*54%WAv zV;!in+SeX&j5k;p>wE;7G0fVO?|*DFf1os(z2IMo-?*76GdSdWLNuhwxldv|W2Y8h zOy-_D==Lm^h;r=i1d@`nDbS76#iDxLq8!ICqO1};b5k4o52d|`@6!yJ zu8X+Ic@2{8#{U3pIHAfe2?poB_`nIKlJaapHo&?cvil*uybMZlY&ibCn_So9)=?AyP*GG(HMUs?EGg}C-u~EvjU6s`qs}vL zh#X1BH3Em`rZLQHD4=~P-p9}6;)*2YE+)%^{sUH3D$ShLEgW{ar-iQV;1=jU*j|jC zp0SnijUNu_k1ES)kpx9#J98NS0Pa8b#N{XGc`X_Us_WW_(@#|80&>zlEA;g$%mv%? zd<8n}DFU=QR4S4PK5h-W;Pw%$>}D^wt8lHhk^XS3B1a-D$*wh*M*4aJFvyGSkr`o~ z!KZW<9+m_T>(=AA!1g=nkccN^r7Ym;Td33z`(QrAL^DzreNvOyX*>S_Uf7~AEWqXA zo*HLqW@Sf_0Q7=R=cdCBG8L(}f=7($WhGDg)M8Fl5>$XxO0htJqhNL?cd(8Jg^@ z2!oe0voY%@V`H$tV}%r+Dv0E(2&EF{>@9NM#`sobI#}X~lT$oVGw;hcz$k~U1tDTX z4I<>RHa~n|=n?WxREr@3a8f04Yxh;$=-xIcwU?=q1Qy4 zTsHpz^w?qO7DpXpq;e|`XKPqoj5}70^{_^*q>7$Ns;3b{7%bArHchaVLaE+>czZgd z&r(^ar`H^BZBKD>I{yGo@fMq7^jgZ}Q{44w9pUxdxb^v*5U`Z9$sv39d*CVHc zi+p^xgmUB99K1u9Q<$Ykc}f-`R0czRh&SpnmKW@k%@js>ww^Xeikd+(gQm;?ABWQ|f66I*I$?@pw^8oO5ijnzuBb9VVhiRc%3B^dranVtIcbj%*Hgcg$uF z8l%stK(LL5+x5kx;YS>46j{9lCS_Slk+ftfjGJlN+y4M>Y&^U~(2prBl@rydj&UR| zt*e_60ggE(;Xg+Cfp|-YX5re|WTmf?c_lX-_BQ~Nac-73IPwnFp3$EiHCbO$UK+Tnrk!pgQ@F6b%O2w0F*k7NJq<`ibO>IiXq{LUDAx?X%r1Ae z`db{i^VBpX=lU&UmoTe=z^M`|UE+w4rHA`%jyyg~Io3v=#HP+yKZh-)GXDU@bL2@{ zVWOTp4@m>1`tAljSosRJS!G6L=_JatvlT(+-c1Uji9$Cce)yEUwbBd9nWCs_Y|N;x z56n%w=8Yta^>ke#6j;9?I+MwNx6IA6Q8kiKbY7$2-o{YW4`g@E= zHW>L4;Kq!&^Z{4I8NP2Mvb8+3O|Mh6K^lj@k`5)~c$j=;NewKLeS?g$vcA4(^cqlX zbR%ihJL&K-=%sID8`*azQ~SFi25O467rYvj2;SfI59Y@olb_;7o<#&w&lXuxQk9Kb z&`9=4Oy^L)X4BJtm`q+|WQZ)Oge0@dQWdL|<&xBM2W56%{%kzso5{=aDv0h@v@Kp? zH3eVD%*|T$NzJNVUZ9`-41jv~J7eeP2{w5%l$3(Ac7kkzT&A8{nQ8Q_%8dfqSa#cg z>yFGXg0{LlaLLhCkb+0#m+oeD>_oLN$FaJ!TEL)L_@Pmx6pmO;Z&Lo;?fdYim@x1 z0+|3hWdnP5`+tm4%aSEQQD##q6*DZeNl_k&94JsnOAl_F;3&3+L7%+EEd@Oh%vouk zK`9jWWJ7()+UM=l3qK!{rb)ut6En{wiYjU+OY?~TfWS!8@gM^zH6w6a8iYSzk0E#O~l6zts^8cO)u zHax;j_w?!f;);P`+{T(El#qe07u9ZueXz}0G?@gjC=V>nr9c5rn~*-%#GGHUt3_Ot zakSDGjms&z$VKjbhl~mu!0NI}XyIaM#-?pf?6xd^*j3rA0(`Ox>6Qs5nw&MrDd^tU zw%g!8(X0-Sg3^xbC1m;#YDnA3+;!?V#T0aFMQUX&!}Cj36p}*DE(DSgu0H4Ujn;*f zkj&lcYiSfxycIA?0g)MlS-ghEw1rJG2T_^k*-1L%O6Wt_a}YFQ-9E#{7m)NpPg5pw zR%xo*IwiTg1uV;d1MiJ?D^^cY!_{(0DK8}4prF~05 z465*0ol=PG%iLJ>H}%RRgY%x^6qAIstwoHy#%x+X)m$5ClzvmT@TH>gT24x)WDd zGDkc8A+7{*+jc$AwizxuUk453^O~5ZMU+Ws$&|7DT)lC2b%#`a$i}5lODZqMEagYuch^rOPU{I)}XI zd1-F8u*36JKxvum$B4LxHm^u(`KB@~V2kNXjhF+l{F9CxnB2M|(=|gY&U5^_N_vXL z`d3pa(!|@qCgW@_I5pXJpP<JD=@~IJ7d?WU+iZ4+9f3 zbDgyhPK^h_vD|xN*6Trg=#T#ZNW+z}TD4jC)C&RD-M|=SjlRukXsus|nSE_aPf;Y$ ztGQllx{?R|Bd6|mU!z>r*Zdx@h`w2;^14 z@nVM~d1T5m6%)w6^DCw@m233?ZDZpR{{R_s=#$6@elln411&31Laa+Mj*x0C-0n^~ z)&%!N-a|i8@ee8@GWk`oUGHlihu;iq5?sbwf;5&;H)00(6g7i0`kKY$ z1pff58j!7tEd0wtv8sjKoG_$PQ(o4WV||X+#-j$)QK~MTTGW1ThIK|l%a`f{mH~6M zh9^iZjcRsKsOl7pl1Ed9NfUQt(iD%>Ue@VsYC|E*0@N@h4QGAN_`n{>XQEXhRXrfs zlZ+#xDwx!;FgFp1@nK=K+|7+V=ok+W=jTS1QT|kPmZ$j5*rC>wWxz*X@Js*2skC zO^C2P827`7ILH_aoySe^jHG%R(t3@++usUeK4}5ABW<@Y;}Y%^v!uB%^T_r$=! zs_HEwpuL6&Q7tu0^sXhRnn)$JwMNBH^u=S5p=Ap_cY=85GONlpK{w3S(%YQ`yO|gL zOXnSt$;(LRoDx=T^52MT^y?#2b5!ih2>^rOgT2N&>Cwwp%Qg6qmZWlPN#R)6T#WIb zNb`ld?0z6A@ymrN;s@v5k6Q>BvHW9}d3V_S8Bv;k(V0{MMGjw8Q*&a>LIOV~{{Yhq z^AGV_G8vcc3!l}ytrS$$agkt6-G}F)1pt&F0BvLA1i}ELaoZUfaba>mvAsr z_V*Xx43k1W$1GYva>3+L>KeU2j8o8k5KH_&TZ>=$Y;L>%09<610a*PXFpBZ8BfZUy z{NhaxnLLun(%NPqC4svO4}3a^Y($bt%iM;D3+e}E{{SZfZ9agBDRn)Ja%$DMxwr$t zz)`Nk`W50?6F>u(xM;5oqrjTdR7&6klY(;9N+W2)p_eK+3^@Tj_>URg`oJaj6pq}u8(HtCDU z6knokoU}-)R4Lc}?}~hM3puFPKtUV#z6A|r>q@AKfB|jCdwbz{uh7bgR+T{5f^GF$ zz~dy5IWN$u2-CP9j9L(n=-kO7q*Vmz(oapg;L1OvDGW+f*4luz_fh8=MTq6FflM~^ zf=5dnI*6`T6%8mqRf`?X@lGVU7PNHgA>_(AkhaW?VlgRT=5#|Z9)at=8qwFs8|C1{ zs!8OBAThSYAMuYnH-jtWx;tUyu9;1o@QY;+4J|{|Q`90CjU^UWU-b^wzl?bKBH^RH z2}@vk26vnAtzA3o6H+vTTE^OCjqmj-@;3JCd{+i{9WZ2ydr11%EQ=`pr+5)KcQ}$b zxYsX)woRK6V^V|v0HHbXZTL1L9XT;aGUk^@Haw0Gi#|fm;mo*ih$=Gd$1k3mYBJQ) zqb`<>$5CO_n^C4 zntH?*f>RiJaullc>Ej-A!6>&!9I?3Vl)0S+B@A%SOHuPTGBU;!>O;_z(4M_9NK2R0 zloP#@Wt37@P}7=(f@P&Z>lCSJBaf-N?cWfd8D5T`iLI8Lj(sB2Qpp;Xk)>zUrC4om zfANm*9~T#G4;1d0%7lanS}_rHQj5z?I&aqI+k=l|m)4G$ssnm7hCm~lq2wmy$7NOC z_B(I=@i^b;t6su#wyLCo(t4kqgs^3jMFH*Lk@au2@p!k@5^`MzR@KhbO0@E-q>XM{ z{VESzU%o7FLel1u7I>yc(1pEp_rBlFZ);(ei6qGyqDrk%$2^><%DU<$?|*xA!AiD@ z(03w^24risc9VSF#fZ5ImX>rAbzvMu%3OVPR$;uU{CsB&cULmaavCw&q)BT^7Gf?fAIB8tj=KSt}t};v@o9 zw2*E-$7>68!2lLvN6BdP8fpGr zmIy?ly+E?w-M2V6;+qSl*)RT?tjsCMY0$mN+QC3Qzg%^2{R1d_Qv)X#M<}?Zvn-o*KG4259a4N=B%Js}-p<08=N`lsV%!ECN+SlJ~9s*h{ zvh3*UiKV2T6)|qeHGyO4uz2aO8oyra#HM2#!lkjBJrPTg&XRs%(pW^h#lbeVk|d5R&Lxr4h4 z1|2Z!dK!^gn^UbsCLobB71SdvSxNr@Rt4ULl0|g%RR)?GcZwQBkeAe{W+L6~+Y*#y zBBTyDRd?Oz&G8GYj(oahwO*{08D0ed8<8b1w0_iStE{Ho|d^FUf$TG zVZ~J` zKt34AQVh{f?>4vUqZtsUS&F`GcCM=pOEu+T+^zE>tpGBh4u?nwh>*vc5!kkhF@A zao4@S#wO{Nlv+Sj<{1|Y<>8WMmYu+oBr=%+1HPM^W6z!}Z)oO}BKjLaoC>SAZ*_|h-a9d_22M?@3$aL6-S#E)KXVX_TDDb+wd?c=U9+8vTp z@D&?WNR`bsd64R6mQ%mDTlBz53uMjk<061c@X^N{hT00Lb|fDJ_4{GcK}&WGU0uU` zEhtRcsc9yDrfrsLk5Kj)NjAr^NxiI?2~aT562!Gf_`l^ z9aN|}>F>YgL7t6$>O z)J>#Y)iXBU+u(3b=p2Zl&MILHsO*aS*?NAMtYDXBunB7Fq++VqzU*5J(it`t2`LS| z8r!b;OW4imiR5RLT>86M?r_YDLnfLuipEQCYhK3-Z5c!po>|JUI~xOT*d32Zk$E*P z#eul#t-9fP7Iqfs?Bk)OwB1-3d4} z%$dd(3_g$z&t9I`!5G@%O|-VI*dY;Psd)sB!8#p=H50N~5P@}7VcfS|Y7b`!qvVpn zdViP9~8M>QZ$Mwb;5$1UoVUn;)`YCByj*w(siM94U4%l?i z8?6=6M|i_46Mm#`jM@(tPnT9fM=&$c!(1)&Oh_No5^NPg)s^{Od`bpc@)D~Z>7*rC zd#S(yS0F_vLl#cNiyToVVkVP7wa1(mYO<_>6!i{o`7Z+)9;e~8p`mVCo5CZLb`w9;t5++($8k5+QZ4)j)WFC4aS zMrf$v`AR1L0GJuIJf1Fm4;YS2iK;~-2kglPI}2mZxi)nqsFA^MO|C_SuwI8vQDFrP zNlMd6^`ANRs0KYifB}t>}-g_+Yf6D0F6vDBH2^pai~UKa95DU!*PxDLtbTv_#JC%iHJM+>eBPF16*P2}78W{gg!}gx4m6F;-py87`#|M21x0RI zQAr~AgohXIZ+oA%AmJwLvYKY6F8GU)W|^%fVMWBBDA6x3_CI`O zNM^~EQBWwEd7BVU*Em%7u~x_>6MBGCs@B-v`}y&UBQ(Y&thdsy44O72E;jG?!nT)Y zCVK=?C7NrJuh6jjdB*Jm(IrGs#F3*+l_ajFWZhM}3-{XvI_wM{71t90!oYe;o8JNK z$r8MUB31yji*HE!juETSdL^Q&6E1@%DU@v+n=^SIY%Nzo8_prF7$DdX-BZ}%;`Or* zN%gUnq_863CiWQA*tG1Dq2rb)xroax&C0*m;M)$gg4gJlNO{UxT}6NZb=YA{lNmg& zk%l)-3IZ`V?}tbOV_9a1lBykSNnYmv0PTp$euqS}86ePFJr2MS0qlI+2J5g(q9Gx9 z3+XGhh0j|a*w%$#**a<<6EGG!h%IsV##$W?Cr%_Y$yX7KX$IcQ3a%%a3%$^M8_ z>_^R`j(DL4;#JfQ_B-$P!L|i#Ix?;Su+n=R4G*$qnNZk)&|7}ER#w zVd#)_0QIrl5%$HgWu?c{IWk9fk6itwGAcee;XIq-c3%jNX|&O1>Y~I9N?BWE*4tsCsOxgh?#?S@!a zux{w7de4$+j4HIXQUDuKvb~PQeBz55Lse`mF3zTkGs{TKnhJBHV#YE~?f1dro{eG7 zu?Nil2t;oFRViDJq;TRZ|3(Hdt$T_T9yGEiUbG_rlk^UWgQNJ zZVvm~3OZ>motQ3P5T==`Dr15tGEE^{*?JPXMecp^o{70vL|K(yQAb}$)H#c0R8m>w zF%qQ5-AawY9W9O=o<{?kS!kpjNUxaH3Nck3FeTDCMVX`iTi>O;fWP!Ur_^o;>R7>@+a7C`z{4r)l$a+ zPnu;%W|k4BnRC~zjyj_D3n5B>l%-Km9A$PTT-Yx7>9TFBISj7RMC%NZCZMuvxdir6 z;@D1T7IcXZ&MJoFrL0^XBp)LG09V@tY7Q$gkcc!)5k!trF0Mb+RP;D0fT5ows;Xvq zsU(%PmM7K=8 zXskdib_Wb4kO>x^x+t0DV0T!fgxN>CcEGFAtU97Pc`8=-B=36*pKJKQ<3m_2c3DYR zF(#5eU94HHz5_$2swwL@ODKItHHw;Dt`J-g#svoG>P(9$rckm&9P(P$)O6qMdSS#H zUqMAvBRn#g39;po{4@3##wxQzQ$QtJW{ASw)kmP6iTn7*F-4QbBvtOKJhd8Q^v3@H z&A&_pHjPqc6mRNi+9yB`n*}8M+pZc;far@bH1xAH@hF;CK#|jO$q0K~j78frDCudl z*)u4fqMDvm2FwIR6ep(aa930-(=};DnIvJPNJXp#n)V(soJQs7lrE*wRVCD&tZi>> z6%$y5v-9bEC$G=bix2fos&1Z{_^H5q;;&a*g@IAgA*l7e+8&dIuw*?{U!5t@eZjQ;>5 zR03v;TPp%NPP;~X^yqpE_`qB2UX4X`s;XY4z_#Qv+Sq53D?w5NlQW=ZPvaTxd1S^7 z$?P!7SI~P2%QA$nsQw=+nTj;8&X-D(Iuq~P{9(BTqLx~U_RfVez{n}$6>-yCvsQ)0WZVByMo zb}J=L_P?jkjCDp%it2$*ca!kFYz2KXQcSWQ%s|+FP9Ymlq0~buT#uQ;t|Kz$6nU4 zAa?-c7<))T9-G_S6)_>5<+N(IW4-TVg>HpuvM{UEjZCL)N2UdZCG07siD72e3j<<= zZa?1`1aYt=vZj?DdVTS#z$;B>-H0CJt~D5U%q(Ml{l`pd9AuKj$*1iv;P1up!%=^Jt|m|*08rr;l-ntWj~x?q1@Ie?5IjF z)!=>cCJ=sd2K241dxu~iSRJSuV-vma!4Ld_`&Q@-A?1}j4co~x{`kQ!5e!$#^T#x*ciI6y@)+F z!n8UN+_wF@cfyKuTcz=hbTZC;Rv|{$C%!SPazaVk!x^mrtw2)0dWVNE znb7PFt#f;K!8KW+%l;K-m5#yThK!BR%*?7s;~LFH@_ZSlq??yh#Cd%E^-{gm#PYyh^5ngPW4yUzWW3HF)mD{2UGEH1!a@4r8FWl=~D{oaNYJJ zuY7A}pvb-^<#jD5%Oy>Ap?7GhuP`tCxXu_+S#gRZyyY zuK0Z*QB5r*)UH-&+BO}X2(~q&Q3L8;tNFuOGA9@4Ht;d7!hzlb4Z`UdRxue?C#C-Y z7%QP{ZOUz8FjJvg9J2$|VZX3Z#lsDT6}#BU9TV7GlD_zxDwfYp_-h9QNlOdy4LxO5 zWRGB_k0n>^G0Tz5(cO+Q_I(*emGE9gmx&4SB=a5bq?DKv#;ZKIt6d9#QC*>;RW=P_Vom8E`BKun7 z6~mh&dqlHh#Fm-!!=NroUrG8$wmnrYNb=fA=xax}Ob{G^FMDCc6^+M>e_RG*wF_(p z6vT?^7qIVaVT9%q1%Nju)y%)$p^4%a88`(PkZ+N^z8#-XK&*l&yxRD;y- zjA6>bcfaEp$8#9>zfrz1gh66&ZSjSYvD)?v*S0a1gk=NWyJ12!sniMBd*RI84i9aK z7Co`3TNF7YZG@5+*r_WkUfufOMQEZW=Q{&%1^afv;*D%7hdZsyWl1UO=ckYxgA0|n zCJ@1H5C>9TWyOVs`_r$?S=MYd1U04Nkyd|k~Zt(+Ws&YQX>W`TKZ|E zrvwH%)!N0EVpndb0R@u0i_B?hqF9tUeqG4`c)lorO0ul0tPmt4Z3g210CR$31W6)r z%s?zH>T3h;Fc>a~p0VSlni(N7nJuDC^(OoNxEzgEMso;h$^h%R-$!e9x10ckM_UB3 ztEnx0ivU9(xERzc8x2hIJ=E)kO@ITT7!(43nuFeCqf(u&rwruk#7g8(x`wdZxgGJAwigj%B(=BI*5F~eGJH^6 z5;B`uH*hb$H^|M!7o0s&OBQ7VRVKJqwKCu8x1VfXHqkm(eSz@T;yg3cK^jOBGy_VF zfF3ank-o~UJs&~vhZDn?LL!-gxZ2|$PDne^*$J;_jr@A}NtUH8Q&dxH;cEGH&!KMF zT}vA+OkNa{H4cPg(5$fIF3Psk(eRHLWm&JoZZfLL>+6K5>BDKDf03hSc zlwLQprY%cHz5F1li;lQwi8xYXuScKd&olt^j-h*xaKK}_Pvpl(CA@hwe7#x1Rg@nv z(>y|Tz2XgPu=;^MM?sGwSm~aJA}BI?!68W%l?vDZ;P2EA&JP_L>}5>^k!fjZ%{V(O zeKj8VUWY*3hV@1mZ@PoNkG3hQCeyJKDTcX<=usmr_hGRck`5%U&1@DL7^zlxxe7_x zGd7Z>^k8~nlGsDx%A-nlWh6f=D;tIZybE~68G<$OVIN|%5uI@^ZIxAlmB*<_y6TH@z4rFQx@5r5#Cf=fGNoF&cgf{T znOy-f%6n;2w^ldrwmh#R6PH9K3oi2<&Uq>57A%Z81lksWBj+f1AKN$YOo9(25E za3JwJEpq3srl>Jh(@iuA6bM(*q*}*u)MKZ{#PO?VTp;2avQ1wPCJI)Ds@fw9y6NuU z)4n}eWKz-4k(#XGc6`ZRuP{btLV0m&1s?X$!0q|K$u_ha;zyV8a%Gb?VIE$~Qwv-? za_-mkkji~5EOr*(5#!6SsN1t?n($fT#i0#DO-}UG{D_tagnY&Wc9Pp_K2Np>#GZ$h zRTQ*858o%K8;rU39=A8Yf=5hm@zNxcL6Pv=(ALh2G(eysq=rpl&s#Acf9s0J5=^Fp zs3<{=VwI|%AjG(jNo#ok;;mOe(CVzR9#E*E%%(0MOVQL*X(4{&4HW2{mcWcIDrSkO zW0IOs2&jb!kr;H+chm2Nqy&iKnst&VFte)d89UhcZwCuwh0yU9Vx0Dl0Y+Lgq?pW% zNIs*t`NJU}V=1#L`jjmdbok6Q6aVV1Z{}Pnye=!8K!Gls-ljSVCF2P44lRqPm2M21Bv5q#N%BX ze6xs>YFXrQPnWE1{0>;VfOY_mhaQ(o!)&#s&OUOET@l99z;{U)29S5PyZd4pGPo-< zdIiWce8)PQN6u2jN|rIYddE{?zSaZ2*i0GTPRXZlW{Mobig=@%86HtALO@E9Yu{o# z?T*O(p2|`{wV9H}0--V6ao+fODtZozI-VyhGi!L^?V;FT{{Wl|VWJs0m8zU1A)Q9V z=&%@88rc|Y3)8)zi8Z_I*DbJ;!o4@1?F!4$DS!H}AC}xhKFJ#ll_MmC{{YEBaqdrS6dPj4RXtv( zjz@UURwnlQ<8cMsI(h0$T(u4pW4mm)G#d5~1yf3SPWA+Wy4Zp}@uj6;uxjb#q!RqZ zPaL|$aip7SH|zRihvunlDqesMM77ctoxV~lTg|wMpRhq>^8Xaw3671Z+ z`L-X^8DvkP9PNVA@h)psoSJ$_77BRWN%Jy9&Z;eYYBv6Zt|=)|btKVe#8c*(mRV0C zv=utR(7KmWf_Jz89sFVrf1w2meSX`~Xus;C1zkrBHU9Xeq-x)zxpZ^V=t>(Ij$ zbZW5@)3G{LfIY3f`dplHJH44i132Q`s+OZlRC6la0vJbV;{@;O@;$NXW2A~x3CS~> zI(6q(RMln(Jv`G&#yw+kVg~;J;|-RQv~82sXF0}WS_WH7GgIo+3Phj<+i+W{$1{^? z61Iy`muDGbRL@Rhda8rXn8_g^5#SxVV$p3Y5hg{L=Gp9T9=Zi;B7fw;CaF%_6MF&g z?TJar%F1ylR-cJ0BrPmYms8Fxud`_#x_3Bu^1YjlY?8C#)ZZwe=IkX6^a#n^_umZD zY@1|oa0pE@H9>L|0u+A_>_@+ojqxT0MwamhJ1Z>03V zYzIsHGCB+P9q_GK!&sZ@bt3*ThD2q8xD9m&t@>jnT@z%g?S9riFw`)Gn3Jnx*>8dy zJDFi%w>Z=Rva_io*Kg^KLa~9}y8&*a2K7RAaFD!(h%66QJx(y=kEfxxi{nsjjCHdu z#mBJ3>t?n)peI#_w_Ffdrd5qa)ZF{v&@I@C!*E8&t~DZv?qMJW9;^26jbITC!BcbR z?}6AGXnK%YbzedM0M3{cZpMa22htm`BwGzep*gO%8)zMdH$Y-MrS5&LzBPbwd#;|t zVQdnKXiHdZKt1t{(Gs^^Bw#im_aW3+;2@zlUWWeIAsEg`(g*5r#yKP-Z*HFWM&F@Z zB%Vlt0SuNZ18Y6}ZQBF>#kMewHX~tzP(@Nf)v@p~j69$Tt7F)VDTHsP+6DZL@Mr^j ziwk}6hSAHp@!#!&YZ1PowXvuc$2H!-6K?)-h8rweO9dsAcR1FKM=T8bY?n8+u&siN zIxZ8=E97AgT|4Onuw^Jf8~3&*<{D-E9|^dQMFr@R4OSs!kaY8couRmvFnkfsr;A%w z(Z=8C^%75v4o2Z&^q&FcpGcE6gfL$&F8~*91k*m&HNlo( zHaKZpA4sdN<9-X4m*q1lsVd`Zp*jQGt*^I!m%>v8qs(*4uZOeKlNA+AU@_W|X|TPA zsGA=+vgAOYaAn7>KdK(CIM4 z@RN!}LPM0uRM=cHgTJ-!gylivXY2S^F`{N#jJ~EPU5GHT{-bPVB>OX3D_SJJqwQAC*uV2mw#-+17vW|=H6W~xOlG2cl=1yX^;jg&- zb;0=JFU=zZ@kWxOgE(qQCTYP@Cbn`|ZgwNE#*GQL*@{44q3v$CxDuhjTmX8m{{Vae zj?<`K*fuG^UfuD96reY_-1N2;j*%I-BIBowGUy!~Mx__&Y!g_i7%D*_NZfni3^jEr zB#Wr-4)_4N8pg)srTSwU+1ka%86cdtdtCLwX#tWtbRY`>{{V*qfnvrFKmosCaj4cw zX7(NqH36}jzlmld*wihE?xc+;wibr54cLG`I3^O;8~%eD!9&mvg8u-f1Ga4oq+a*6 z@D_?8*3)gl`{0;Hup|wSfr2CKaVKp+T>JFKu#Hx0*><;EoMw;{{SQ|41Jc{y0U`J7 zUTX!@a96E}#N`kNQE>)imy|TMlhc*xB9N#bj0F^p$(qcg<2Ms!RtB(E#yX`+hWuZ) z72{0S&8AKJLBgO%n&pgxyp)fqf$j+0eXyS!T@Ih@+GIZ!_*%TJs(^Ca)7AqK_Vo-S zjE3foNAD=B<#9N0CBq( zz0a}zFu(K{vN>urL>Q@C{{WzO#So*^!A%RyDizsA=$}|8$nk~+i%%mxJ=Nso5qlk& zez*+Xoep4NQ7bj$PeHldk9;Lq-4Po4NTo6bRWft{cfl~^A)+!gAOX23cPHBg8ibK& zp&!JIrH#NQ{d@akCu~-Nz!Cu_w6T2*fv(4E+>XP+z+g;m$h&Zx*Lk176)5*kGE-BCT|qG@R%c1g*Ct#uA%mK-^Ko(&ssJwG?qXOG?)g04y*3 ztb1P;j$RIkPkJ#qWqBo)meMJ)zQ^Al<}9jl*JqtH(=<@bvH@ZRyI*`+U$Qitu<${; zfW}oy-68cM7h!!k1-xLxse#eBmTpIvxFXtH6G^uqrB$97nI-E5oVa}l2>apv# z*bUfuP>Tq;2m)LAyPOKWFhWYlG)IjrD_Q9k(lYI@-D#@`>dY^nF{R#g7VFOrT z;xaecfw;A>v<(vc)T@Qc^;;{Rthh(-)$3v(flhjw6FKjp^w{6igJ!0!Ud^ z?YUd_z608}Tdt3%{v2_?J!AeM>F05Xa713Y6m-?G@QEb?E1 zyiRC1t0XIr#l{xjuINAWL+XkwNbDL#4K5yt2bs^8b9 zBa^eCJ25p`d{bqmnyMM;mhxy*d+9c?J#G#rm5wre-U#y8(CLI}2=LU{sBYFH`{EfY zA+|j!smK?!QCxj3sfo8T2YX9%+AoN}UhTbho%4oGm5*S~{wfEfP}4REr<+lAsVkC$YcjfXzyV zQd7_K`eP|N!ol1jxdZHXHo$886)QBEJe17yQGC5bu1_@TaOH*WKpjB$>M_re>X2AI zZN;?td$yRTOuB7K$$exVp#kbU^~WYjOOB0gkEYLZiKwZjr`J71chp=E-}^uvb|bDQ zgO@Fa*pxg-vr4hgLkyg@BbPqRhp$7|^~a#&%dwlV*LKWdQj}`tK`LRpGmG3@cDJ@F zqLKoWMUGdW^3pbe2`nthCCZW8RgLyIRT^fqrv`UWB$g8Ec{Q*gpKm{$T-1og4J|ZM zIz(PVEzRm!-@lv+Gw5_F8p&ZQqm;N!u075*2p>H%h}9%u085vQZhRlk8E9k=B67%z z5-ht&8SSfW{fAr%voJ-CB36-sYm!H!eY!RK;UyG=O`KgS*t3mE^oQIsp9bH2GE_fg z5mUiT^Haf3$-Uizxn-1{*pCO>8i8$eK}qp42=Z&C3s+Xi<^)<`QXr>rI_sGyMUHz576 zF|?k*q*~H&?D<|y&{x+OXA%Z`C~$)P7u$ZP9sHFOeUw?oZ%s*4Rr|KGc_*B-Qf?Pt zV`2JZk2AQ4-4!_}6W3+gn6IUcsv0=?bFQAg%s&17u`d>UTU0E2G<9DT=2~cD)Q?fI z5mSdQ-p0bi?T=nERcz@|y^qSX-0O;}_44DQg-51GLO1R@<8n=mqeh08FRG`NwV0CR zwcl{xf6g?haOk;+idsZl?m`RS2(E$$S;UmoEGeohbflXI?Wmu?-w5Gk+Y718>7%2L z4rFSOs6>ddT_pbi)8`V5SgODx&NQPbieiYu&0@g)jxQBMlm7EA=;=lTZapXcUAFw< zfWOfsMxsJvm4r@qxFoP1*bULQ>}5?YWn6Pd9b10L7uZD-OEpVLbdD!C)Xa51 zk56HN&yvwZhGx{z(bCIOtLm^ireG5IGk;Q2{TN;}_@kBNzby`6wR5(CD3NBhr3cal z#^T*^oT>5AdY`TJwWzxk_9UEr3 ztgEgmHJvjl=ujQ3IuZsuaYe4nMmA_+JXM^<5uYZCB1lJ$I*&pvx|SdoKGwyZ$qu5* zhxm0{Nm(US8LNEU_H6)=kPf#C)ZC5mu#3Hv;=Ptq@XtDwrF~n@NVBLcIo`~h0rv+F z@i93VY}QS67JEPBvZODU`VHt?)BMXPzrsr4*Hl#d=UNW(yLD4XM!OPAB1mY}MsyAnCB zs4Wh<(8_u$D}QL3>7it#%js!F{{Z?SFLB#$m}iZo9!`wTVey-Y>YTFX1|U}2 zDbynW0Gv`7?QD}}6;B=Jb==N&Wl-$nan3%VJb~jCQ2mQ+qNvVPUr^?1-Hr7Ueep#U zO}SYCt!dY1F|Di@89^bEB2ocX5(i*@kaifNqdgXR9$i($Ih;9V6+2H=JB5u<84>l&`2km~C!m*%PI$r(G7}k-?6}oPH z@IpS!h%bHnV;DjFx4HH>#P?%lW8ZGr15puhqQLGvV_Gnxa&{}Xlivr>1l4_p$H~I` zG0aF~b8og7B7!gJ>P3lRjA|Ggwa)kk6gH9w>OZa&VeT~P1E{|E#uyv{zpCHU7-WP$ z#J^GpW7iA@ni>f$qzfOuGZC~p;QD&ot%elcj~YVzU~Ho3W%nHo#@9I82+P?<+h48< z7eazcj+Vpe08rpI*S-37#?$D+1I%N&{0svQ1TC2EM@$t=Nenh-ENy@E;U0xJu?M*a zwlPZ-T|uz8@r*SbJw$qcOdT4TB6>A2^n!3ZWjqI-=dp&O%Vw1u zeQY$Z>T#^bhKJyOe>|X1$)zW)-&g5w_?w!#86y6h;CwNc`KsBUN%eA~^w^HNj@S~O ziczA<{ts~d9Xd@UQq@_8^05a`_`V~|T4ug}6UgJIi{$cp9Jvf&2q_}5YagwR@2L0p zz~nquhg8DmIm8jPm1R#XIN8rl+qMz0s3t|#9CAwvAY}=qNh0H7f36)c(m5%FYJf88 z1hTH?#@lV*2-~n)L<>PIlg~R#d34z7@qWXl@N7Jos;i;Ys10i={{U5j2IHM~%Plg;v zSw5P)`Qx?6q1}!D08xyP%~54R@H&EJ5@s2c(#S2Wizxj~@ucgaQohTYKZIO4O;Y^o zHjruCnK5El&AJ==VL1)N(b4c959OSbO_tLxqitNU%)Z;<+{3{dII@(2HI@h?q>FL7 zC?EYP7@L{6*F%0p&!SgwtS%Y3VM`Aoh8LLXG)*R4fJZt5Be$u{mkQo3ewa>Zr^f2a z`k2G$JcFT#DC2O~-~3?n1fc4{e|ARdKY)$Zmi8d~+pl~#CPJ7n%HWA2Fd{}wexi|q zWAAZ?QZ*S~B=~iZ=hGyWd3;dRvC?X3*Ou&Uu)q7_ib&O?8(;f9K!p6RcPiPGGDwQ+ zr2VXKgUJA!CHO;|aPDEOSHo3LA`l^X*$&5Rn~+KKg`ZkuM^9+=C`{1Ku94HwqNx%j zNv~5_?k~{(G0hb#+a7ItMJEyP7E#7RN$aB~xrT#Qg3df2f72ZikdjB6=05`~R$FD$ zeCn|wVk@Qe@8@h?NirrIGT{8@D+JVKl`$Yc=o(2N#jb4EhnNc)T^;t2J7pBN&s1Qs{8 zz~cZz5Ri`8Z~7X}5#6^R{9_r90>h>6j48?jw?aPH#v1$dB%cEq4C4^CuII79uuy=4 z1?{)C0LK6Z>;=1H80+nDY&;Q+VE`uEoA~X5FR{T$8*Y8~z|iQEKtBQKG#x{pW)xDZ(^XAOLH_{gQ!)Yg7@NkJ zQlndwd|}V>#tijITk6&S01}sNyb)|K##J+AmHd0>%D=oa;3Ly*aL9FjhZ(|$Ox5K- z6u5rAXrmRMDAH}Fs_B2p+Y_f@vu4#a(m@)<9CNMrkr)ue*p2XLQaE9wb|x9xIa#d9 zC(^^P1KSA3K^2q{QiSI~UYYhfTE^q4{NQ#FS)vleu|;h*40SHyZPc7&1xH9=fRN21 zixvldyAQa+w|xrA-X+bOhqAS;YIInjl@f9olCiT`n|ogxT0u>FC8*9K%jJa0G+)Lc zP$(X|^tG^8Lbv)IIwZ0kRN z(=Di|u8JpO(pE&%LXW2Jr^lOqxQELa%B01;fmCr!*&0?u^DwBACQ*CYz#E%)wmkm; zCT)G9bL76!kj?2+GNq=?D5E_47Md9BeJg7=*ya3hz}W&I8s zu5Nywwm5Vq$ykXLT>h9)P`Xn=v9-UK8=z3-QV{t+gruZq-9aRTY(-7ct^)HYyR@Di6J!|2OdPLEqDYEVL5z`Ur z7L7CMjt$J>c;nC=PTPqO`{SBh87?f%{?gU7+$Y0Xe;mZ7T8V4omQqbi%c^N%SCZ;u)LCP3>H)aRxFJ~^mNqqj=5aQRsx*I;_=hPy0mpM{a5f_1Bb z*cs$tPJ(Qt4#W$Oe0bj@j_l^ilk`{R^>ESU)lnqNHA5&-F#4juV0-sCU-KIFMP+T! z6;(;e^7>_lv8OUbU7>Zk03Ggp_s3j(r&d`v?7GY4j!5H{Jz0$_$8?f3W-Le6t^Saw zxj5{>*kRhCmqbaIC2@_!j|}T_OdyL71lw=6 z1sXau3aBjbpr(wVTf-}QhfqW$fI!8Ne52{PJAVl6C_C@rX6Oq$5Vo+JgX!>IDA zdCXx9OAvlyxr71*zLMX37~@eNM^Vu}U0mpBs9rZxU25Vk8vSizE#wi3v?Z2RIb}5r z!7}={BbFXHB8bLOyNezF06p-O>@T27LrcEJ8*O9_qjVs%^Kmv0p|VH2_mlI6&^U^}ARf1MPuK z0CC6#N(o|}QLU)inOE#bOcVm%SfY+8WF$(eHCo?M^KQ60GaE@)1!+d7VH|G6GE4|9 z>K4CUy^ZnWLnP%oXB=FtKCX&9;*xrjC#i}#9EF8_ZY(T6>favxHxs=_ zR%A0=mWr$R(NIlESl}$N)U}&Qx2SmOY;oqDIyvS5+&5R2r7~r2Q9VS#iwOpi687J} z=M{rVS{?}&O~X0tQBxXBwsBUGUP_vY7f&$vP&#!x6e+etc#Jp!u_#?u{kn@GBDB^y;}=@r>Vix(L#31BNXcB!LNEY|-3&9O*J znYmbv4rxI*u6V|uL%VEIuhZWS<3>uz260ZV8foQJNB;ntvGikcw~RFA;*9ASYM+Tv zQgH|F`4N&yB++?&D+?WipY;n8e@uB3oTSbynHqWl_=Ck6{{RO(ZBHx99W;W~$UQbY zfY#f4?fPS<6q@YO%-(@`lD~*3G6c-C+R8eqYV21oo>Yl2k^Hf<9FfJ8IwT9jN;Z?9F%166V(qwrqL~|;LTjtzrVO1cz8(PdqKn1qw zF=dMObhM}sfpbXnY|^Z0j-6tc(=<{O6OA`0gzUO++pZZvMJg<-zA@yPd)2GUYN}Ug zxlT#eK(7X~xSMJ+GKthwo_+M*UU46e@5Y>0a)9m&Nbj>L1bHB<4*MW2}+IFdOx z9M;`@{Q!PL}C};bPk( z8Kaqjad3M#OXDcJpiwZEN{3VjRFAMh=i3)hMJVNw8gp_;+!54bv5H0`Y}Q2*ksmN9 zvW6QEd_5yr8LOJ3(jp88UwmpsFGSEt_R(!1_v|n_0Iws4U`lHHTN=RFGE=^?`fPgR z0?AdIr~yw;xW+Y-(?(>OBaH!fU;=^ElWSl%M(p?c87O`L@WIR{hAH^xF^sJ|PIsb- zly?6BQU3t87qHzP4VmV38Lf2nRdTe`O6A$y^(PcbBVB{@jAqa42e(6PI+J<@3@;fZ z+^Y0l?}cCxzK{;32gR_a5v8yj4?7G7VaoPWZF`GvxWyMnBV`W7i2~gK!V1nTNK27_ z0~iMoz^13z^tLgPG6oH6kFXfSjw^Gp1$*4%7(!dIx&3ex7OdnB!H5K^{{T0PQtT*l zvmS$Qd|;8Ak=NDI!x+OzZOyH>LyQzeOIxSujYte^deyCcR~|8hA9HKt1bW6?64p0A zk&H0Y(1sfhm%_6TSAa)y7)lN9Eo)#Hh=RMF#qJ5lF!3SM6kAa^3@GBIR{ML~42B}r zcO#&~66Jax0JZOo7LnSB0^idZ9dtA?)In3E`}M-vMD#e`{$o?5MMY4|cOSuP zezw8W2NM35;eQd;6$3740~>3Zf)2P2k&-mj9|9}tP#TK(AaV6Zo}xTh_rf`(Q6lb# z;8t1^^)+>p6ML1ig+4lAend9QOuykp6$B-z!y3Ghtp~}c44d2si5ruIXIw8!yHe?|* zQd3n_)F$zn5GW__d;b7T4k5CxqvLL2EQP5uKsMO}AJFZGiv5b%F!+JS*}L;8GHVN7 z+?FHoO|fR9=#yjCFNpc7NVi&L`iost{qZJ{Q)8&UA91#5m#NOVEDzDmVo$fG*nI@a*B$f#1A<{EhtNf-$pLaIm|1%ZFdYgN zmf*xJeTA^RjY2dM#WJ%s!zjBaKya=@rJ`p>D&(Cg7gHA4mB6sjG_N!)lSI%+1fVdL zb$Us+Ku7C`uw9l>g-sQ4avfopNrBvY>~|I;3fYnwQ(PsL{{VoA{6=jHZ7L4n54Vg8 zv95_@s})j4U4UEI>pqq9daghe?~|)Ol><_f95vz3)={>>~E2@k=2#? zo^J&t8JyJBhAl=o>7fw-0oa}PAb7xWraw2vfvJ{rQe=WvB=5_%qR0OLb}p8VR`yQ= zNGH=Htmsain)*+F#x)B2IIbQBwhBXfAxc2X_Rt#lHy!Y=u~4Z>$N**v zLGFLH9h4)Qla%bPo|1mMkapj$0gk5}*q=#OPy;I1lh>v2C`+-RN%Pu8);@>SYyjMY z=M1z8CysWhr+DSCh(AI6-s1Q+Y5~mnLnO_lf-0&Seq%7Rl(SpEPS|gf$D*$__&>vy zE)(~9)1x7?#7Y%6`}KLN8?-NZF? z(;}M#atXE>WI*C&a}S3cL6!z-vbm&CZK@%xc;#QXNfFx6WU16UroWT@Q;0Jr;KH)A2Jj898_umofFi2Ben z+iz?*MmJmO(t3+{!bro0=FPe7=Ga3GXq6o49+T&;9LHNx(_p{n7{?XTy*4<;5fb+H z?S*C>!%JVNBlN&9r%(pgKG*4tVJ-BrJC3%)C1w$rcI(pE)L{&F`gg*ZZJVc#*kogo zOKc6h-~3>hMH-2|!u_y@5%yay;A0r&Z6e#>-x$M#U4@Cb-q;NW#ZuBSx1qZZ*eM#t zEb301DYnD5s^ZM+wmbA4}z{)J8C1G#H z?SkT%+?lP&zBF+LPo-p?E1^;eS>qa;&#SlJ0pU$p(Ul&7mi&LqD_kyPMD!-xOA*$; z?lH;1rZ+Qv!@m+Ef|1}B?}b0p_Jgvn%~r;5HR zN2rA>VG9C8n&#EmC>wbm*kuS#e5+%rHbI+Zt;4Si!}DtyMH0naf;kb5{aQ!zn{~(9 z_&!pSQGSG+8%35&n5>|>klSvz{NwGbx*9>9CbklG;p66^Wi$a;h8#4{NV=9pJPZdVPt6#VT;)*Dm(+E~l*73Mw zit$t#1=HS8LMuu~Wdz^!#M($J_?ir_EtT9}mZyLJ05aqc>4>puo1BM%CCrcr;h9fc z7?>aJgtG94t(%S=_-mPEwPDRH);&gpfZ0k&_TCoAD(M74<8`p!>uY13*_Ob*JbWk5 zJ}K}LS*uS!NY4A$An>)*>AzX^O(U_?m z%FxOd@2FbfHHrOk&eQC_D(Lx(C(oNFo?c`|Xe9tk5Nln3)I2ckeX*pC$o3zG`Tkj3 zpV881ar>@r-I4k{|CnZnak$fefRWn7bdXR3-(1HdX7^J?|cg}JgHRf=54 z%<4q2v&j-dpe%|Mu>$Vj;}ON4rc)f3vga_(Dd~_7YRK9{1zy7451f1W=A?C}%b+S; z=7_-3&r*;J2IUW`-s7>yU9>Y)GMhP|uARA4tm+qTNZ1kP{{Vb$OvOJMaf)!ROFc*q z)g&L6`Iab-_Pw_D?S*n;Nzvsz8S#R--!**3RAgA1q9Gz&DP8mqoo}`%x+2-A;I2B% zIL5x7pu)6tks*p$(Ai{|_g`Q!IU@MqHM3`&P|)RBT$zP+ai@yFnI2C`Cu<$H!HeF< z_EJw(mgZEPsB5Yv)up*Afz`$Pn_j^0hjPW-T$(-gAR@KO|)b2U44Iud2+Z^8nQz0c|GLAZ|q@=8* zo==*is!cAEwylRtU&bjMX)oJ3SL*yh3se<{ZYJ zmIkPTLnLV;>Oj`+4_`QCjUglZF0;>yx$b=w(N|2mTyCins(^cKil_}{YFzrQV<;zd zh@03F0KaesDZwKE)YbADLd;ya1erRv15{2?v!l%Q#^4*BwnMf6>LAlj+J>b%j{6<( z$(oLcJDXUaa&XO9NtTVB@1&~rCmCqO^U~edP};+F+W0hLb%_~Dx@>!n*vT2OT@@{$ zYzIN#-wX>m9awAz8AVXHvF$8$@UT=;$GdNA8c3yr^M;dge*W0aS*(b%$al5I1p(}P z7Sb34vFvfE6f_18dmSgJ!*Nw$_IsDYZWp2Wf5Y;8LE?Chq!!8OTo2>91alZ4nmr$!@Us(0G{_yD3r`ful@ zv5iEM6ksk_*xRl#sB1?4;0^JDNzCORSh@BXRNL&r>x>I&^&Xqx(Uypd*^P~dLM?&^ zt(<2Hq*})Y!h|eEt_iT(*wzh<1nTsgTm3@#78k9GRO$?OCw{m9>~M^!E$7Z107(Xu zYXUmpy%`9g1t!+Qr(+AKHSPtvZZH{$nRQ=lTebz5;#iIFOmOuTBdGE)0z7r-tVc{9 zjbjx?qE^l13^6(tf{&+j;{;h);H-!?vA}vBEPQ^WzW&DuIW#m)Ixt0Nn)V2y`*%Lr z-3N(h2Lk7HAw*eSO`mlxnnA|oYG#s~;Fl3hk+g{oC~^n!9^?bufraHx!A#NR{{R8P znBKCz!?Xz+%a~FiQ*=Qnu(#XJ3Y3r?6&atz&KH35 z7Pp=1Bb5+hK*P4!D5xJ7@(OV)#Y_#Krk+G*+~9_$7G z0Hv{%hEbxzhv9ZbOE9OY%UVlCXys-ttox3~2GAd7t193;n=hdT47!<9ST?XXHtIX= z;}Ur&qKajOJsm1Zq8JuG8Y2J(J8g`c4+KV(O9Um->$Z&p{NoQu znmhcjHs;s2q;5YL)?|SyqWN};S4P$W0RI56?}Tp0Q6-u=j8P-h4pyTfhRB$t;YQ5cqLc@b{rRs;>Y;d^BzEoh1w)OBb~ zPA72BN8Uv{kNe=!tQHKuINIQaWo^q| zez)K3k&un57YF*wl$J`yH75e*;Wtr4S-?O83b1?6v9grB(aFt zqg`wdz9+;flF3;lY$Pfrzf>m1-K~d1(L4(CJLynlWVu^`WgDN!!wA8dnkj@T#{EKp zaz~6BCOIkFnW;(C%0n<0A%5MkdNo;BS(MY(Xcd%k)u_6;uxt3iQfS-}MVR~~;jGaE z8h?{;Gy_iB8r^PupS~SsYe3+ck<2~=(a6($hISOH5)!R6kljY(sJDMOb(EZy89M&} zg4|C+S<;pY$klJnr<4);9r1oip-jbp31-=3fokX~Aim%{XZ&r1PxfS}uH`&zZUx8k z^uw)zp>FD3RX_~3VbE(_rsu#E~UCy-uN~XgoCID zRuPy*km@~&?s1WYHc@?DeBq2R4P$MH?dJ*_I#HyMy?cxR(HPa|7}Pm#p|{-k!9?F= zfa{LHUAy~W{{YZvjOu1lb78i_59ri7Wih?4aqclaJ&c_k7>&U{oEsZNiA^G>FpC3j z`!_z{;em*Cn+RNk`p{-bUR;7gLSa+h2<8uQZGT& z^)syzq-JhLzGz;-t+^QB%Lv|y$+OZvAN*Fy_-ijpD(t_N2|lS{Acs2u%ntYKfx*^` zK^knAi1=n1*dH4n_=M!&@fp`eK56j+qvl}=npV|iY&BjwaFQz#aJFG$y{~*uO{fVgE?Yf`mU_&hj;5Zh#hOsNMI=hrBwp(vw@rz^oKO5k2gwpx)!DbnQjU)#OxC)R zo@&8(d9_N;XWqo!kK)}hu1^BAR(w*XX7idh;fWG-E26ELl9@)5g8KpFW52`vlX{Wn z$wjimF5(1DD>kSFuVc0U09<`uFC!e+WF8|$24NhoIZP}D#C65KMBas1>#|m<7Tk?q zdVz*h1ByGG6?Y(9>}~!#VQeZVJmxekE(N-iusAnEQBZT7+8q9ikYb-IWGOnI`Ku@L zu=eY>z9^(ZQKITh=;f8Vo<-4McjGs}&LgI^ z>dcBQV`JY3lzp)AY`25ZpzNa|iiVXTtx8DdVoJ#bVPs%BT6^`2GNkx6DOvg62vno(ob*K8?e|yQG+8%1wuQZ zv5mF_bhyT$Uc}{d+?6dH!tuJ>>GQblh8l@dnUxwL8!~CP@d)W|x5C&OIMSG;Nv8;; z3lgA$JYd)e<%X(9j#_$jWYkgFj_N%7<91-PMI?&zh}K$ofHDSSs^|Wm{{AqoAtjiJ z=K@IemEB8ir@!YIG&yNe=Kv5v@4i>l5`cGACw;p8v5iGFR|!!3(XVLlR?l~L8iQE+ zZQ~f!Sy!t;MkW&mWxuCU0Q=xjEU%-HOq!Kg7h9LUrT+jJD?#ijDZup=B@}8KZN49| zdIJ9d)zvk$&+?N~(_RFSf~Qm<*fqy;Kh8dX84R)AcU4K zev5<9oO%*>M_rnXriLycr4r^XPiKpkwB|q^oE<@|J9XOzSglz^O;48Pbg;aUGkmtK z4;}Vb9lrkEvBB{yR@pZTFuC^;=2;5V)aAvarKPgORe|N3p51hj*B)+6Jf+PX6UR=- zsD2~KL&9-EYO37X+DDb3KoSz)LKD`+TM$^9m6CB~j|yhfXKP~C!nl&VFr!sOe5gvYvuii(a8oAP z>p2G$kdt#p#AaXN&OP*Bc)ypKY#SCF|S~cAJu{}w| z)($L5F{6t!I(}4fR!anNCXkRfED_+_d|5})uSG4^jym^ubWr+z?4uD7Hgk(`-|Sp2q390fPg3-uqxsTA;3DbY1=J z(+-dbDyriAu;oUGG{klvQw(H< zB10=UAwXN$3_Tc5WbY^OZV+}I@uLj7Rxdgha5obs`kD6_{K9Ns6|%N95@{rdz=dtVovu9r7k-9dteyg z)(vsHc^JkPMQBk$7HeN_;~2wAq^hmE9`_c;Fn}tHDYuK`7?B83a@RdJ#xShm^#TQt zp7_QSP#|d{ z{SlM>ag1Eid_B%<6?D-U5dQ!?tQ3D!fn!m7Pw_N4xwg(AA`I*N`w9p-*8JyDSf++z3_P$w4(TV!}K(|6DOrCWDF;k zAkLt5Tb{>lupUYhO3SRjE}?*}I#N^8p*l+lKv93T7VK!~c%@2ehA>2uHm^%6fE%zk z#I4wB#N`g9Lh-ru0KhR@t*wlt5yk{5eOFcPfA5Fv)JS0E$cq}Ht9pqCO^yc> zT?0t6)6{GO8(bY$9dM?XXFEu-0pO9d?4g#;Km9q#^H!1KtJz+9>G>cEQRDe){&n{ z(#LgQJKq&#>X;=ZWOZU+;YysQ)BI#APq@EdxWxU9=$%0cX$pn0(iKju6AqF_CYD1^ z6_ZN<$#r4w0q1dmK2(HbelCq*$Xc8dptCEXo)vb2WFS7d_8ZuxM*@{ybSt2vC zNp?V-z!u-kJYWQ6-X`S-7i3#ldoQ*F6_QNMj`718sCfuj+BMtT>~H`>9S_UT z%2%1>eLBHi49(aOHpK%ZK#lVcBH7kWT3k5V{q2kzv?R35@)--W5!Y^`+X9VrHDDSV zPH0IK-$?`?dv-X~D_5~3iq927kt~61S(I3B(!}qBLTwYzP-*F2nJ+6DeNiCPHs0W$ ze%K~BPp(Zx7#H1^*9YzXaf}-fhG1B!*M8QvpSA_jhf~2uQP-C8>V3M5Zp==!sF0&Z zMx8}UZb>*5Lm`sP19DY$+iie4N81Vz+lv*_HK+s&TIc<+OjhPp^3?`()eNdNDF=Ui zU@#|K#a0(J9N;!(Kj+Wi43I3aF|9=*P>ma(r0y6VGw1zR?e@g1a(EgIM6`D%-B-pLD>59@EVC?PEkqEdlx<;u7^f0a z?2c#}dXXSH8rNrxSpC1Y70JbqMAIY6rKLrvZ{{s)pKk{Y=VG)})o`XunrNxaGWcqx zP*U#@TMokg{@8UkEfiJ12l!^brgGFvP0V2;v~E;;t%uX?hvp?2+|%}YpqgiT48m%3 z?F6aJ(tK*_alSyLV{>1DTt`J2lAR*2P4t?3g2Vp+X~QgmqZwDh*~Jq#%w@GO#-Cd> zWP$k@Wba@q$`oq?HrRuT7-fxxffl&{V*uwCa20`G?QZ@sC=7~7LmQ2}j~EmIB>-JU z{x5(aiai@0`eBgBPFGEdw_Fg85fx!&y|=(-5JnpJL#zEbRAH|kqi@h*%p);~>~{NM zMjNSG*Ec7vuncy?p}*f4Ar$O@XkZvN_>`Rykct9>Z#aj^Oio)Pl>m^n>^ozsGUkS| zNZRUOvWpOLDK{5Fx3Q(gmcVV^-`@+#kI0%CK!vV!uX|!Lv3VWOvKo0Ia~2_31}4_+`rtfwvr!!6%nC@m_5fn(B(^%y zJlTsETL2vZQ>SZzj(OwxIx?Q<)6sD=)KH3QrjlBCqbU?&$yk_iON;6 zKYOssk})=>4g%^uynA9Zeu_eTjepFX*M??z<3y!_0~(hXk)#&%A8!P7?~Zt+ot9yo zA(TM;M?o%QQ#7Xb3I{0T|hlH?e@pjV9MIqB?Q7~{xIkC z{IKm5;0qGVV#Du_#gL1{Y&dJ;^CohrRFI4}WYUZL1gK zqS}V4ilP$K=p<4#Y6AOWUiKQTghyAGNv7`|&ifI$!F)=mqDZQ;_?GVR2EX$)&J0$x zEh1W;B*`-9jFmOCu%|jv307hRr_|1?|#?jKq_0A5PK)WBw+YH=dQZbc} z;Ed$)>@{^&)M}6;goYBthugX7d~oKvhmNuya|(hHqJBXXlme;u0<@d^JJ!2 z#-S0vK=)<0bqBb|T%#EwBI;Ww;rc1Ey3E5Stf5@HH_GJ^PfYKqD-MjL?of@?__jRv ziACAeq>Uq1NMixRIX_f}=kz#UNTLUxdZ(_17M42d7ejf>#cC0}fJLqO?TPlr3d`g9 z8OxBh3T|36x1!x|efH~uz>c6%Q8cDyh2i>j0&b*rz5q$8C@7j9TE}G(?KYjQ!aupbOzw3wh#;=Hypl8%zmqbYup~7;|fa*+EvRqjuq*w z*;m}0GB7&lG_?dXPXaL@T|oZ;!`m5!3nZ*-%g3c6=woBLx3{svj7){%nVH9_x~OfB z+Ze>lIAvCNj;QZozf%vk350G@w9-Q&L}Rgu&4Ty78iXAi&_P6AI#)G3&r>S{8%J)I z^L#5A6}461E11;^5xXmN1FpyWVUUdToUXEhj-5Xo0lIh zffT5vulTu9CSF>SsiCiqQh^u=5!1^lAEmLOjggz;XEL5DiahTxki5~usB@cH1&KTK z=mFegy(&XTA?uZY7IG|>nxYzwS(6o6BM1N`?XhBZ>G|7yNyC#Y8GngH~v9*A`u)iAx zS;<)DP)nUda&5L9AcdOIDgqRa_8oCmqY0u()ko3+y~)8bbHdq`9!*^%=2s<~vQfv8}1B_I!|FWBNaBe4=Aqcdd_iRs+MAO%YR2_XIO zsRS{6*+ghf_icg3O3+3+feMhna1Js6QT!+NiXyiFA^I8o&= zktShW$J0+4y}$ZqBEWsmY)zQa{CoJ99}wqbhjMq0J{QVD!Alef66eHTCU@v|>nDXgx3Y z#zE9R(B9uv0F^(lJ$8dmde%KdANVm)Qb2H3&vHYy4(OH=#1Tj;!z{cbk zWL!bQ^5rqo?`M#eDd%yW8fa%aQa}jHbSHW8lNeLP+iQ{X8leT z$g0vWhY#hMVl;HLFeoadu!%+X{+&)0I(7*wR2LN#I#enoR^I9?e_R(fJYh&`QHdrp zJDygO2m;{aDOwTs4>(#g>$4IzW%VB$_`$OeH0%X~^3?1Q^d8v55zRtdt8Oi8oB*X{ z>q>PJ6PAZ#ZTGid&M?7a3)~*JIB!Dx7LH*Ml>{pyor}mXr1>3&B+4P=#>;4s4#%*+V`1O?V<3Vo zvn4r>ssxZ&?vLpP{`hlQGdnOq3W5N*BY(lh6`_v|NFCBJ(vUUU`FU>oO@jcChb!Al50Uj(fP3qfjhZ4gIa} zjB62#Ne!d{6>JcbV&8FwNH$L;Oix7uMNJq;#if=pa@RW&d<+pEV6p|0A~Yf}^oBk$ zjEB7{{H#SP6y30P6fEkiBiW*3rHC6TJqg2h z0ab*~16!24w=irl%wJ>KtxqtO-BLgW{r=ctM-37| zCdNTvO9O2_e;5=CB~a9=qD5FsAZ3uSApO1luqf6q%nn-0qzxk4?YH0G3@F1`@yI`l z#RlLhu>_8wV+O$2GFmwUr8JX5Uqi5A=^jYF_`$MjjM6%rMq_A@jhRnl=fTDljOL3I zg6>NFC>-3j-hUWIV2Vu5Dy2f{%YFS<*|zEb0G)6sq9%@aRwTI>C)B$e9^Y&@SsX+( z4H7%qH#P*XUnd!pLxpLI_dKV)!ETsQiCT1#ipW)l;O~4etb3}gaTp{iVQ>cIcE(^5 zDds4zEKeeXrJM^ju%n_!sh*;8WqnO;BH#rh@#6-}*&|EIwv=NTT`k}r^=*w{vC-8# z)WHdkP3#PbW&>`A?~KAq)d4j}Dyq8xE^fB`VNrtVbSwroP#XL1f6wWHVXqicRYEzx z^9_#uZQBauVr@ov!dYUIQD!Q7TcP&Cr)CE-q1LBoRk;e?F;rrzNTP^IAR^4bl;732 zZrF9B6j}cO1!R0h3pCk$FfmO=qQOd@#^b&lofC09@~7Y`%T6k2vldlhsYK`n{{TPd z46>7PGS$Bbc!COrhmlVsy}ew`Ad~kPZg;Vg(P0T_WH&u|=P}`qHQvfG!Y)rTPMj152R07c$nStL|d-cPr z5w-yrcrY}c4aw3Ox zXwiWxN{|>1wmt2LzBfZ%i^~%2vfHV~l~IQ%xzd~5br|8vHuQ7OUWskhuj(6E;wm<* zDk`joqRIdaTHS4qoO&4`Hm`fS@1&izbvUe*y9*QM8=3$D-h1I3Kopf5Xlr?}!Yvwx zyQFq2(2I4xHQ31!7P9PZzf3v}5-0JLsUZmHeBqvrLj+A5UG1j*hWJN2&@475L<~UH ze?3MyXR}!nz?|PuvAyg&;)&=|TeLGBDmUm(7H>wbS{6xkJJ^Dx-`e)X_;Nx1CAA+E zOqqLA2$fe!OM`7d`SXc<1yt<^)A0pPRYx1p)(U263r_@O62N^oU-bTPC5GbA7*!7y zW*Pqg7bRrXN@l-0HmQ56x`AtZ4fezy3REN6zR0-C=4CW>Z!JY_M9(XDHS;rJ(1`S@N27qvuVYaa|S&IyH1fF$8C)ITi^adIT)EUZPqwXKM}dl_UbvX9>R zWGzcinpM;zY$HMyK(&tGbo-n%aoZo{(Vyb_>TVyVdT69a%p7hI+(++z*fNTVljM2B zR7xvZzmrOV@SvWHd#_yxbVCp6|xD#Baf=2Wg{sFtdKE-2hKWFX<>;l4QeB%Wl~5R#5-S(VAOYPp-0J-%;Fd=EVi7AGqHAJm$WJH}t-ED%9!>OqrO33*WK&0yCH089tyaC_er<@T<4HZmj zD#;@P?dmGT+Ws%o7{g(WS5axQxdi~j&@V+1`f&PPpCCo-;3>x2edj$NUG`|S1`;|m&_6nTgSEo*`WA{zwnc^Qb?Ce zj#waV|Ha8c<_)$wHNWmbTt=|Eo4Y_GAU=rI{ z;HcO~r9!-7J(L4-*53~qaTTi>G~kN{4X3cezq1SIfvTDI14-$8ZiPALc!AQyTy@5K z8pSilVhjs2o}%3_WBLPRl(UD4!{1N`Ngi>TlCV9!ZgVoWZbTy+Z3t|iyYj;eaC}+ z@TMi^*aLEHf&wOyOJ4q-_Qo)eG7xR3k%0DLB-E>Bk4d$`)qt%SNh1-WvaoR7hf(c@ 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