From 2d00514e229e30761d0c36b6bfcfce3178925fcc Mon Sep 17 00:00:00 2001 From: Alex Date: Thu, 3 Nov 2022 23:36:53 +0200 Subject: [PATCH 01/93] build: harden docker-image.yml permissions Signed-off-by: Alex --- .github/workflows/docker-image.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/docker-image.yml b/.github/workflows/docker-image.yml index 76e0c1c1190..1d7237c5b05 100644 --- a/.github/workflows/docker-image.yml +++ b/.github/workflows/docker-image.yml @@ -9,6 +9,9 @@ on: tags: - 'v*' +permissions: + contents: read # to fetch code (actions/checkout) + jobs: push_to_registry: if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' From d0afd218e179edc124b3bc2fe4738da817fce948 Mon Sep 17 00:00:00 2001 From: Alex Date: Thu, 3 Nov 2022 23:37:27 +0200 Subject: [PATCH 02/93] build: harden golang-analysis.yml permissions Signed-off-by: Alex --- .github/workflows/golang-analysis.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/golang-analysis.yml b/.github/workflows/golang-analysis.yml index 3a74e61a26e..b9476f94ece 100644 --- a/.github/workflows/golang-analysis.yml +++ b/.github/workflows/golang-analysis.yml @@ -1,6 +1,9 @@ on: [push, pull_request] name: Go Checks +permissions: + contents: read # to fetch code (actions/checkout) + jobs: unit: runs-on: ubuntu-latest From c9f944cd624c7801c9790995b2d175131021bd06 Mon Sep 17 00:00:00 2001 From: Alex Date: Thu, 3 Nov 2022 23:51:49 +0200 Subject: [PATCH 03/93] build: harden sync-release-assets.yml permissions Signed-off-by: Alex --- .github/workflows/sync-release-assets.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.github/workflows/sync-release-assets.yml b/.github/workflows/sync-release-assets.yml index da3ca9582b5..269352bac7c 100644 --- a/.github/workflows/sync-release-assets.yml +++ b/.github/workflows/sync-release-assets.yml @@ -9,8 +9,12 @@ concurrency: group: release-assets-dist-sync cancel-in-progress: true +permissions: {} jobs: sync-github-and-dist-ipfs-tech: + permissions: + contents: write # to upload release asset + if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' runs-on: "ubuntu-latest" steps: From 9653185048dd9e4fdb2dc75e3c751a4072b73bb7 Mon Sep 17 00:00:00 2001 From: Alex Date: Thu, 3 Nov 2022 23:52:00 +0200 Subject: [PATCH 04/93] build: harden codeql-analysis.yml permissions Signed-off-by: Alex --- .github/workflows/codeql-analysis.yml | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml index af9006adf88..4923571a6b5 100644 --- a/.github/workflows/codeql-analysis.yml +++ b/.github/workflows/codeql-analysis.yml @@ -11,8 +11,15 @@ on: schedule: - cron: '30 12 * * 2' +permissions: + contents: read # to fetch code (actions/checkout) + jobs: analyze: + permissions: + contents: read # to fetch code (actions/checkout) + security-events: write # (github/codeql-action/autobuild) + if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' name: Analyze runs-on: ubuntu-latest From 5d60453326b955745be7539b4cec25c86a2e4921 Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Mon, 27 Feb 2023 10:49:21 +0100 Subject: [PATCH 05/93] ci: ensure new interop suites are executed --- .github/workflows/build.yml | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 5e350cad77a..6a373b84c9f 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -42,9 +42,10 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - suites: - - 'exchange-files' - - 'files pin circuit ipns cid-version-agnostic ipns-pubsub pubsub' + includes: + - patterns: 'exchange-files' + - patterns: 'exchange-files' + options: '-v' fail-fast: false defaults: run: @@ -74,7 +75,7 @@ jobs: npm install kubo-rpc-client@^3.0.1 npm install ipfs-interop@^10.0.1 working-directory: interop - - run: npx ipfs-interop -- -t node $(sed -e 's#[^ ]*#-f test/&.js#g' <<< '${{ matrix.suites }}') + - run: npx ipfs-interop -- -t node $(ls test/*.js | grep ${{ matrix.options }} '${{ matrix.patterns }}' | sed -e 's/^/-f /' | tr '\n' ' ') env: LIBP2P_TCP_REUSEPORT: false LIBP2P_ALLOW_WEAK_RSA_KEYS: 1 From 7cd7c67fb362ef0e807ccafc3620b6b2281586ad Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Mon, 27 Feb 2023 11:10:28 +0100 Subject: [PATCH 06/93] ci: fix test extraction in interop workflow --- .github/workflows/build.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 6a373b84c9f..c7c17a43e1f 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -42,7 +42,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - includes: + include: - patterns: 'exchange-files' - patterns: 'exchange-files' options: '-v' @@ -75,7 +75,7 @@ jobs: npm install kubo-rpc-client@^3.0.1 npm install ipfs-interop@^10.0.1 working-directory: interop - - run: npx ipfs-interop -- -t node $(ls test/*.js | grep ${{ matrix.options }} '${{ matrix.patterns }}' | sed -e 's/^/-f /' | tr '\n' ' ') + - run: npx ipfs-interop -- -t node $(ls node_modules/ipfs-interop/test/*.js | grep ${{ matrix.options }} '${{ matrix.patterns }}' | sed -e 's;node_modules/ipfs-interop/;-f ;' | tr '\n' ' ') env: LIBP2P_TCP_REUSEPORT: false LIBP2P_ALLOW_WEAK_RSA_KEYS: 1 From 0d7c892cecd81eed22ce141608df698ba6902b78 Mon Sep 17 00:00:00 2001 From: Laurent Senta Date: Wed, 15 Feb 2023 15:31:54 +0100 Subject: [PATCH 07/93] test: use car fixtures in sharness t0117 --- test/sharness/t0117-gateway-block.sh | 11 +++++----- test/sharness/t0117-gateway-block/README.md | 20 ++++++++++++++++++ .../sharness/t0117-gateway-block/fixtures.car | Bin 0 -> 309 bytes 3 files changed, 26 insertions(+), 5 deletions(-) create mode 100644 test/sharness/t0117-gateway-block/README.md create mode 100644 test/sharness/t0117-gateway-block/fixtures.car diff --git a/test/sharness/t0117-gateway-block.sh b/test/sharness/t0117-gateway-block.sh index 5f1d080a3d4..d5e40bb830b 100755 --- a/test/sharness/t0117-gateway-block.sh +++ b/test/sharness/t0117-gateway-block.sh @@ -7,12 +7,13 @@ test_description="Test HTTP Gateway Raw Block (application/vnd.ipld.raw) Support test_init_ipfs test_launch_ipfs_daemon_without_network -test_expect_success "Create text fixtures" ' - mkdir -p dir && - echo "hello application/vnd.ipld.raw" > dir/ascii.txt && - ROOT_DIR_CID=$(ipfs add -Qrw --cid-version 1 dir) && - FILE_CID=$(ipfs resolve -r /ipfs/$ROOT_DIR_CID/dir/ascii.txt | cut -d "/" -f3) +# Import test case +# See the static fixtures in ./t0117-gateway-block/ +test_expect_success "Add the dir test directory" ' + ipfs dag import ../t0117-gateway-block/fixtures.car ' +ROOT_DIR_CID=bafybeie72edlprgtlwwctzljf6gkn2wnlrddqjbkxo3jomh4n7omwblxly # ./ +FILE_CID=bafkreihhpc5y2pqvl5rbe5uuyhqjouybfs3rvlmisccgzue2kkt5zq6upq # ./dir/ascii.txt # GET unixfs dir root block and compare it with `ipfs block get` output diff --git a/test/sharness/t0117-gateway-block/README.md b/test/sharness/t0117-gateway-block/README.md new file mode 100644 index 00000000000..8ca237345a7 --- /dev/null +++ b/test/sharness/t0117-gateway-block/README.md @@ -0,0 +1,20 @@ +# Dataset description/sources + +- fixtures.car + - raw CARv1 + +generated with: + +```sh +mkdir -p dir && +echo "hello application/vnd.ipld.raw" > dir/ascii.txt && +ROOT_DIR_CID=$(ipfs add -Qrw --cid-version 1 dir) && +FILE_CID=$(ipfs resolve -r /ipfs/$ROOT_DIR_CID/dir/ascii.txt | cut -d "/" -f3) && +ipfs dag export $ROOT_DIR_CID > fixtures.car + +echo ROOT_DIR_CID=${ROOT_DIR_CID} # ./ +echo FILE_CID=${FILE_CID} # ./dir/ascii.txt + +# ROOT_DIR_CID=bafybeie72edlprgtlwwctzljf6gkn2wnlrddqjbkxo3jomh4n7omwblxly # ./ +# FILE_CID=bafkreihhpc5y2pqvl5rbe5uuyhqjouybfs3rvlmisccgzue2kkt5zq6upq # ./dir/ascii.txt +``` diff --git a/test/sharness/t0117-gateway-block/fixtures.car b/test/sharness/t0117-gateway-block/fixtures.car new file mode 100644 index 0000000000000000000000000000000000000000..77da1b5542e281eb1c80a4a8763c85bd7424b60b GIT binary patch literal 309 zcmcColveYNahp`Ifpb-g~vLz*Snd z?RAF`b4q5BLWzWsh6*V>uh`vdCmNq5R5s<{gXzJHI@_hzc1&o=xiBke z`JKa8YJ@lwi<2`m^-3yAB;-M+I}@WTBQ+-{Um>xeASW|9u>|N@{j$6iz087~6uqLv GaxMV9-hqPv literal 0 HcmV?d00001 From 64ccdbd6f26bcd0c24a27d209b662b1fbe80648c Mon Sep 17 00:00:00 2001 From: Laurent Senta Date: Wed, 15 Feb 2023 15:43:03 +0100 Subject: [PATCH 08/93] test: use car fixtures in sharness t0113 --- test/sharness/t0113-gateway-symlink.sh | 20 +++++++----------- test/sharness/t0113-gateway-symlink/README.md | 16 ++++++++++++++ .../t0113-gateway-symlink/testfiles.car | Bin 0 -> 282 bytes 3 files changed, 24 insertions(+), 12 deletions(-) create mode 100644 test/sharness/t0113-gateway-symlink/README.md create mode 100644 test/sharness/t0113-gateway-symlink/testfiles.car diff --git a/test/sharness/t0113-gateway-symlink.sh b/test/sharness/t0113-gateway-symlink.sh index 9fa7ffa6edf..ea85b815000 100755 --- a/test/sharness/t0113-gateway-symlink.sh +++ b/test/sharness/t0113-gateway-symlink.sh @@ -9,26 +9,22 @@ test_description="Test symlink support on the HTTP gateway" test_init_ipfs test_launch_ipfs_daemon - -test_expect_success "Create a test directory with symlinks" ' - mkdir testfiles && - echo "content" > testfiles/foo && - ln -s foo testfiles/bar && - test_cmp testfiles/foo testfiles/bar -' - -test_expect_success "Add the test directory" ' - HASH=$(ipfs add -Qr testfiles) +# Import test case +# See the static fixtures in ./t0113-gateway-symlink/ +test_expect_success "Add the test directory with symlinks" ' + ipfs dag import ../t0113-gateway-symlink/testfiles.car ' +ROOT_DIR_CID=QmWvY6FaqFMS89YAQ9NAPjVP4WZKA1qbHbicc9HeSKQTgt # ./testfiles/ test_expect_success "Test the directory listing" ' - curl "$GWAY_ADDR/ipfs/$HASH/" > list_response && + curl "$GWAY_ADDR/ipfs/$ROOT_DIR_CID/" > list_response && test_should_contain ">foo<" list_response && test_should_contain ">bar<" list_response ' +# TODO: it's unclear to me if that `echo -n "foo" > expected` should be a fixture somehow. test_expect_success "Test the symlink" ' - curl "$GWAY_ADDR/ipfs/$HASH/bar" > bar_actual && + curl "$GWAY_ADDR/ipfs/$ROOT_DIR_CID/bar" > bar_actual && echo -n "foo" > bar_expected && test_cmp bar_expected bar_actual ' diff --git a/test/sharness/t0113-gateway-symlink/README.md b/test/sharness/t0113-gateway-symlink/README.md new file mode 100644 index 00000000000..350405e321b --- /dev/null +++ b/test/sharness/t0113-gateway-symlink/README.md @@ -0,0 +1,16 @@ +# Dataset description/sources + +- testfiles.car + - raw CARv1 + +generated with: + +```sh +mkdir testfiles && +echo "content" > testfiles/foo && +ln -s foo testfiles/bar && +ROOT_DIR_CID=$(ipfs add -Qr testfiles) && +ipfs dag export $ROOT_DIR_CID > testfiles.car + +# ROOT_DIR_CID=QmWvY6FaqFMS89YAQ9NAPjVP4WZKA1qbHbicc9HeSKQTgt +``` diff --git a/test/sharness/t0113-gateway-symlink/testfiles.car b/test/sharness/t0113-gateway-symlink/testfiles.car new file mode 100644 index 0000000000000000000000000000000000000000..88e5825f3029ceb158138812c946825544704d26 GIT binary patch literal 282 zcmcCmlvG!RGgWg$JoF~Sh0{cmy(cz`^^ncIdY^b8_T#q9k%X>mgtKR@Vd1l;Qez>Zf=ID z2|~NuBOwJsCUfy|FbQ!a=jWBA=9O?sZ~y=yG;7fS literal 0 HcmV?d00001 From 771d62c8f4877b12ed0074a5186f5cc2a33be888 Mon Sep 17 00:00:00 2001 From: Laurent Senta Date: Wed, 15 Feb 2023 16:00:05 +0100 Subject: [PATCH 09/93] test: use car fixtures in sharness t0114 --- test/sharness/t0114-gateway-subdomains.sh | 32 ++++------- .../t0114-gateway-subdomains/README.md | 52 ++++++++++++++++++ .../t0114-gateway-subdomains/fixtures.car | Bin 0 -> 1518 bytes 3 files changed, 63 insertions(+), 21 deletions(-) create mode 100644 test/sharness/t0114-gateway-subdomains/README.md create mode 100644 test/sharness/t0114-gateway-subdomains/fixtures.car diff --git a/test/sharness/t0114-gateway-subdomains.sh b/test/sharness/t0114-gateway-subdomains.sh index a7e5a59c938..04f762ad68e 100755 --- a/test/sharness/t0114-gateway-subdomains.sh +++ b/test/sharness/t0114-gateway-subdomains.sh @@ -91,27 +91,19 @@ test_expect_success "ipfs init" ' test_launch_ipfs_daemon_without_network +# Import test case +# See the static fixtures in ./t0114-gateway-subdomains/ +test_expect_success "Add the test fixtures" ' + ipfs dag import ../t0114-gateway-subdomains/fixtures.car +' +CID_VAL="hello" +CIDv1=bafkreicysg23kiwv34eg2d7qweipxwosdo2py4ldv42nbauguluen5v6am +CIDv0=QmZULkCELmmk5XNfCgTnCyFgAVxBRBXyDHGGMVoLFLiXEN # CIDv0to1 is necessary because raw-leaves are enabled by default during # "ipfs add" with CIDv1 and disabled with CIDv0 -test_expect_success "Add test text file" ' - CID_VAL="hello" - CIDv1=$(echo $CID_VAL | ipfs add --cid-version 1 -Q) - CIDv0=$(echo $CID_VAL | ipfs add --cid-version 0 -Q) - CIDv0to1=$(echo "$CIDv0" | ipfs cid base32) - echo CIDv0to1=${CIDv0to1} -' - -# Directory tree crafted to test for edge cases like "/ipfs/ipfs/ipns/bar" -test_expect_success "Add the test directory" ' - mkdir -p testdirlisting/ipfs/ipns && - echo "hello" > testdirlisting/hello && - echo "text-file-content" > testdirlisting/ipfs/ipns/bar && - mkdir -p testdirlisting/api && - mkdir -p testdirlisting/ipfs && - echo "I am a txt file" > testdirlisting/api/file.txt && - echo "I am a txt file" > testdirlisting/ipfs/file.txt && - DIR_CID=$(ipfs add -Qr --cid-version 1 testdirlisting) -' +CIDv0to1=bafybeiffndsajwhk3lwjewwdxqntmjm4b5wxaaanokonsggenkbw6slwk4 +CIDv1_TOO_LONG=bafkrgqhhyivzstcz3hhswshfjgy6ertgmnqeleynhwt4dlfsthi4hn7zgh4uvlsb5xncykzapi3ocd4lzogukir6ksdy6wzrnz6ohnv4aglcs +DIR_CID=bafybeiht6dtwk3les7vqm6ibpvz6qpohidvlshsfyr7l5mpysdw2vmbbhe # ./testdirlisting test_expect_success "Publish test text file to IPNS using RSA keys" ' RSA_KEY=$(ipfs key gen --ipns-base=b58mh --type=rsa --size=2048 test_key_rsa | head -n1 | tr -d "\n") @@ -600,8 +592,6 @@ test_expect_success \ IPNS_KEY="test_key_ed25519" IPNS_ED25519_B58MH=$(ipfs key list -l --ipns-base b58mh | grep $IPNS_KEY | cut -d" " -f1 | tr -d "\n") IPNS_ED25519_B36CID=$(ipfs key list -l --ipns-base base36 | grep $IPNS_KEY | cut -d" " -f1 | tr -d "\n") -# sha512 will be over 63char limit, even when represented in Base36 -CIDv1_TOO_LONG=$(echo $CID_VAL | ipfs add --cid-version 1 --hash sha2-512 -Q) # local: *.localhost test_localhost_gateway_response_should_contain \ diff --git a/test/sharness/t0114-gateway-subdomains/README.md b/test/sharness/t0114-gateway-subdomains/README.md new file mode 100644 index 00000000000..8f0075ccd7e --- /dev/null +++ b/test/sharness/t0114-gateway-subdomains/README.md @@ -0,0 +1,52 @@ +# Dataset description/sources + +- fixtures.car + - raw CARv1 + +generated with: + +```sh +# CIDv0to1 is necessary because raw-leaves are enabled by default during +# "ipfs add" with CIDv1 and disabled with CIDv0 +CID_VAL="hello" +CIDv1=$(echo $CID_VAL | ipfs add --cid-version 1 -Q) +CIDv0=$(echo $CID_VAL | ipfs add --cid-version 0 -Q) +CIDv0to1=$(echo "$CIDv0" | ipfs cid base32) +# sha512 will be over 63char limit, even when represented in Base36 +CIDv1_TOO_LONG=$(echo $CID_VAL | ipfs add --cid-version 1 --hash sha2-512 -Q) + +echo CIDv1=${CIDv1} +echo CIDv0=${CIDv0} +echo CIDv0to1=${CIDv0to1} +echo CIDv1_TOO_LONG=${CIDv1_TOO_LONG} + +# Directory tree crafted to test for edge cases like "/ipfs/ipfs/ipns/bar" +mkdir -p testdirlisting/ipfs/ipns && +echo "hello" > testdirlisting/hello && +echo "text-file-content" > testdirlisting/ipfs/ipns/bar && +mkdir -p testdirlisting/api && +mkdir -p testdirlisting/ipfs && +echo "I am a txt file" > testdirlisting/api/file.txt && +echo "I am a txt file" > testdirlisting/ipfs/file.txt && +DIR_CID=$(ipfs add -Qr --cid-version 1 testdirlisting) + +echo DIR_CID=${DIR_CID} + +ipfs files mkdir /t0114/ +ipfs files cp /ipfs/${CIDv1} /t0114/ +ipfs files cp /ipfs/${CIDv0} /t0114/ +ipfs files cp /ipfs/${CIDv0to1} /t0114/ +ipfs files cp /ipfs/${DIR_CID} /t0114/ +ipfs files cp /ipfs/${CIDv1_TOO_LONG} /t0114/ + +ROOT=`ipfs files stat /t0114/ --hash` + +ipfs dag export ${ROOT} > ./fixtures.car + +# CID_VAL="hello" +# CIDv1=bafkreicysg23kiwv34eg2d7qweipxwosdo2py4ldv42nbauguluen5v6am +# CIDv0=QmZULkCELmmk5XNfCgTnCyFgAVxBRBXyDHGGMVoLFLiXEN +# CIDv0to1=bafybeiffndsajwhk3lwjewwdxqntmjm4b5wxaaanokonsggenkbw6slwk4 +# CIDv1_TOO_LONG=bafkrgqhhyivzstcz3hhswshfjgy6ertgmnqeleynhwt4dlfsthi4hn7zgh4uvlsb5xncykzapi3ocd4lzogukir6ksdy6wzrnz6ohnv4aglcs +# DIR_CID=bafybeiht6dtwk3les7vqm6ibpvz6qpohidvlshsfyr7l5mpysdw2vmbbhe # ./testdirlisting +``` diff --git a/test/sharness/t0114-gateway-subdomains/fixtures.car b/test/sharness/t0114-gateway-subdomains/fixtures.car new file mode 100644 index 0000000000000000000000000000000000000000..bc7b913dfa27573c76673744a7d15df6a885e891 GIT binary patch literal 1518 zcmb`GeQXnD9LKqJF0;ypXM$%)qznuxqXXLO6<<(B>E0+~lC3KP)VtnuFTJ<6&-Jc% zAZ8emC~AekvSdRu6%$2pDmVyKbW4oUh*Ouak!YMEFO$(kV@4F?-TIe*wK4wxe1E_1 z_w)Tds|P?zQB>G{VOezX9MmN~(GT9Z{qdnmvbArh-#syZWbfg+Tan$T4@h55eY@f; ztAP~c6&blvUi>i{an_)&H@Tn7FI=1Wb${3JnFYlCebrK8&fHYrI5rZ0MrqbM(YnW^ zu8yz}42300@JCyjAlohnjRv+pl3BNTUDR0L)Y!N&qJ$g5d^FUGRiVJS1nEFs(N|8K zs2TgAQmW1m&iixxn*|^Km5d$7zuvuP;7Y?EIS2X>MKVGP@G%3jUZ240nhyu8mkuO# zz$Y@g0%^sYFmRF9aIZ{}X*MmUf$Y}^Qo<_GA;h^J>9~9C_)FH>jS%Uy6m6hZq5P>0cx{A{x167X4IXPgm9G=!hNcl5z z%n(d6!TXdLjfVQ>ldKqnmUWv@q6GFfA%g-u!^kuw<2on! zL_H34oz5g>Rf_#$dF}$EKoWDMP0zHBACLO-}0A%ME6Wp7|2ub%9_vC zUORPPXk=Gza3*{G?e`WvFk6JZhEoYz)vX->2DGF^@Ki!GiDW|Ic-o4|LB>c0M8A|U zAgy~fiJ~}wz2-oNnG5tU7n~W9Hr?-NQS^b33-9l?*R}IyIwW^X%ccU0^X$ zvx}5mq{|YyY_)UWEX<-I{(~j7t^mm0H@&Is{G{{mu_pNH>0R@m?J@7lwGC|;xu>Q5 zokxEewE@Wx3)vAmZ9YW>cC%L0g@>Q_W*sNTZUpY|gtsF3{I*8<`0M+oyE~6==;=-O cqYjEpVW>TqDCNBhGOEXh;)yA;3S`y!570JmG5`Po literal 0 HcmV?d00001 From 8641d16a2b3acec0d5ff84ae9bbcbaa14ad6f436 Mon Sep 17 00:00:00 2001 From: Laurent Senta Date: Thu, 16 Feb 2023 10:23:37 +0100 Subject: [PATCH 10/93] test: use car fixtures in sharness t0115 --- test/sharness/t0115-gateway-dir-listing.sh | 18 ++++------ .../t0115-gateway-dir-listing/README.md | 31 ++++++++++++++++++ .../t0115-gateway-dir-listing/fixtures.car | Bin 0 -> 1053 bytes 3 files changed, 37 insertions(+), 12 deletions(-) create mode 100644 test/sharness/t0115-gateway-dir-listing/README.md create mode 100644 test/sharness/t0115-gateway-dir-listing/fixtures.car diff --git a/test/sharness/t0115-gateway-dir-listing.sh b/test/sharness/t0115-gateway-dir-listing.sh index 708e0c4cf8b..cf95bf4b05e 100755 --- a/test/sharness/t0115-gateway-dir-listing.sh +++ b/test/sharness/t0115-gateway-dir-listing.sh @@ -18,20 +18,14 @@ test_expect_success "ipfs init" ' test_launch_ipfs_daemon_without_network +# Import test case +# See the static fixtures in ./t0115-gateway-dir-listing/ test_expect_success "Add the test directory" ' - mkdir -p rootDir/ipfs && - mkdir -p rootDir/ipns && - mkdir -p rootDir/api && - mkdir -p rootDir/ą/ę && - echo "I am a txt file on path with utf8" > rootDir/ą/ę/file-źł.txt && - echo "I am a txt file in confusing /api dir" > rootDir/api/file.txt && - echo "I am a txt file in confusing /ipfs dir" > rootDir/ipfs/file.txt && - echo "I am a txt file in confusing /ipns dir" > rootDir/ipns/file.txt && - DIR_CID=$(ipfs add -Qr --cid-version 1 rootDir) && - FILE_CID=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/file-źł.txt | jq -r .Hash) && - FILE_SIZE=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/file-źł.txt | jq -r .Size) - echo "$FILE_CID / $FILE_SIZE" + ipfs dag import ../t0115-gateway-dir-listing/fixtures.car ' +DIR_CID=bafybeig6ka5mlwkl4subqhaiatalkcleo4jgnr3hqwvpmsqfca27cijp3i # ./rootDir/ +FILE_CID=bafkreialihlqnf5uwo4byh4n3cmwlntwqzxxs2fg5vanqdi3d7tb2l5xkm # ./rootDir/ą/ę/file-źł.txt +FILE_SIZE=34 ## ============================================================================ ## Test dir listing on path gateway (eg. 127.0.0.1:8080/ipfs/) diff --git a/test/sharness/t0115-gateway-dir-listing/README.md b/test/sharness/t0115-gateway-dir-listing/README.md new file mode 100644 index 00000000000..8b6e332750d --- /dev/null +++ b/test/sharness/t0115-gateway-dir-listing/README.md @@ -0,0 +1,31 @@ +# Dataset description/sources + +- fixtures.car + - raw CARv1 + +generated with: + +```sh +mkdir -p rootDir/ipfs && +mkdir -p rootDir/ipns && +mkdir -p rootDir/api && +mkdir -p rootDir/ą/ę && +echo "I am a txt file on path with utf8" > rootDir/ą/ę/file-źł.txt && +echo "I am a txt file in confusing /api dir" > rootDir/api/file.txt && +echo "I am a txt file in confusing /ipfs dir" > rootDir/ipfs/file.txt && +echo "I am a txt file in confusing /ipns dir" > rootDir/ipns/file.txt && +DIR_CID=$(ipfs add -Qr --cid-version 1 rootDir) && +FILE_CID=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/file-źł.txt | jq -r .Hash) && +FILE_SIZE=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/file-źł.txt | jq -r .Size) +echo "$FILE_CID / $FILE_SIZE" + +echo DIR_CID=${DIR_CID} +echo FILE_CID=${FILE_CID} +echo FILE_SIZE=${FILE_SIZE} + +ipfs dag export ${DIR_CID} > ./fixtures.car + +# DIR_CID=bafybeig6ka5mlwkl4subqhaiatalkcleo4jgnr3hqwvpmsqfca27cijp3i # ./rootDir/ +# FILE_CID=bafkreialihlqnf5uwo4byh4n3cmwlntwqzxxs2fg5vanqdi3d7tb2l5xkm # ./rootDir/ą/ę/file-źł.txt +# FILE_SIZE=34 +``` diff --git a/test/sharness/t0115-gateway-dir-listing/fixtures.car b/test/sharness/t0115-gateway-dir-listing/fixtures.car new file mode 100644 index 0000000000000000000000000000000000000000..71a5603822741f25320438bd70823589120e313c GIT binary patch literal 1053 zcmcColvR$Z!{1TqeSN@tUjjg{Tlgc7mrAdS5w!gPn*17KH6I(#F3Vnld4xzQ6ixRGTe(8O`Zyg zxeAF2KuroD-3pm`3d#9-X{E)PdFcxJz;IJY$t>amyOUtJLEZWM>i;({85gv-W(d_V zKa@*2eN@-d)vWbj%$Z-NzS6vINbXbzxziiuPC}aSyAu>)2!|4kFsMU?&s>>u#q@K) zg=4JD+Ddu%u4<)wm#M_8IM$cG*3(nQFic@T$&fnuIuO3{I&*k2EHJEuD( zXEu8GPP(?~NTtQ!*2R(r|4!eUF1UKJ@frzWikc}A4+_gfkg)`nn?n*5x8rrT>037M zkdg1bF*9{rSzCT(#hs2>E#m S1&JjY3gwwVqO>H Date: Mon, 20 Feb 2023 15:57:38 +0100 Subject: [PATCH 11/93] test: fix prometheus test folder path --- .../prometheus_metrics | 0 .../prometheus_metrics_added_by_enabling_rcmgr | 0 test/sharness/t0119-prometheus.sh | 6 +++--- 3 files changed, 3 insertions(+), 3 deletions(-) rename test/sharness/{t0116-prometheus-data => t0119-prometheus-data}/prometheus_metrics (100%) rename test/sharness/{t0116-prometheus-data => t0119-prometheus-data}/prometheus_metrics_added_by_enabling_rcmgr (100%) diff --git a/test/sharness/t0116-prometheus-data/prometheus_metrics b/test/sharness/t0119-prometheus-data/prometheus_metrics similarity index 100% rename from test/sharness/t0116-prometheus-data/prometheus_metrics rename to test/sharness/t0119-prometheus-data/prometheus_metrics diff --git a/test/sharness/t0116-prometheus-data/prometheus_metrics_added_by_enabling_rcmgr b/test/sharness/t0119-prometheus-data/prometheus_metrics_added_by_enabling_rcmgr similarity index 100% rename from test/sharness/t0116-prometheus-data/prometheus_metrics_added_by_enabling_rcmgr rename to test/sharness/t0119-prometheus-data/prometheus_metrics_added_by_enabling_rcmgr diff --git a/test/sharness/t0119-prometheus.sh b/test/sharness/t0119-prometheus.sh index e96b8b96f8a..3387f4feb3b 100755 --- a/test/sharness/t0119-prometheus.sh +++ b/test/sharness/t0119-prometheus.sh @@ -27,7 +27,7 @@ test_expect_success "filter metrics" ' ' test_expect_success "make sure metrics haven't changed" ' - diff -u ../t0116-prometheus-data/prometheus_metrics filtered_metrics + diff -u ../t0119-prometheus-data/prometheus_metrics filtered_metrics ' # Check what was added by enabling ResourceMgr.Enabled @@ -50,11 +50,11 @@ test_kill_ipfs_daemon test_expect_success "filter metrics and find ones added by enabling ResourceMgr" ' sed -ne "s/^\([a-z0-9_]\+\).*/\1/p" raw_metrics | LC_ALL=C sort > filtered_metrics && - grep -v -x -f ../t0116-prometheus-data/prometheus_metrics filtered_metrics > rcmgr_metrics + grep -v -x -f ../t0119-prometheus-data/prometheus_metrics filtered_metrics > rcmgr_metrics ' test_expect_success "make sure initial metrics added by setting ResourceMgr.Enabled haven't changed" ' - diff -u ../t0116-prometheus-data/prometheus_metrics_added_by_enabling_rcmgr rcmgr_metrics + diff -u ../t0119-prometheus-data/prometheus_metrics_added_by_enabling_rcmgr rcmgr_metrics ' test_done From 284bb8c819fbd8d50e757f733957980c183855b0 Mon Sep 17 00:00:00 2001 From: Laurent Senta Date: Mon, 20 Feb 2023 16:04:16 +0100 Subject: [PATCH 12/93] test: use car fixtures in sharness t0116 --- test/sharness/t0116-gateway-cache.sh | 15 +++++---- test/sharness/t0116-gateway-cache/README.md | 30 ++++++++++++++++++ .../sharness/t0116-gateway-cache/fixtures.car | Bin 0 -> 468 bytes 3 files changed, 38 insertions(+), 7 deletions(-) create mode 100644 test/sharness/t0116-gateway-cache/README.md create mode 100644 test/sharness/t0116-gateway-cache/fixtures.car diff --git a/test/sharness/t0116-gateway-cache.sh b/test/sharness/t0116-gateway-cache.sh index 0af4ec0eb71..508fc73c288 100755 --- a/test/sharness/t0116-gateway-cache.sh +++ b/test/sharness/t0116-gateway-cache.sh @@ -25,15 +25,16 @@ test_launch_ipfs_daemon_without_network # Caching of things like raw blocks, CARs, dag-json and dag-cbor # is tested in their respective suites. +# Import test case +# See the static fixtures in ./t0116-gateway-cache/ test_expect_success "Add the test directory" ' - mkdir -p root2/root3/root4 && - echo "hello" > root2/root3/root4/index.html && - ROOT1_CID=$(ipfs add -Qrw --cid-version 1 root2) - ROOT2_CID=$(ipfs resolve -r /ipfs/$ROOT1_CID/root2 | cut -d "/" -f3) - ROOT3_CID=$(ipfs resolve -r /ipfs/$ROOT1_CID/root2/root3 | cut -d "/" -f3) - ROOT4_CID=$(ipfs resolve -r /ipfs/$ROOT1_CID/root2/root3/root4 | cut -d "/" -f3) - FILE_CID=$(ipfs resolve -r /ipfs/$ROOT1_CID/root2/root3/root4/index.html | cut -d "/" -f3) + ipfs dag import ../t0116-gateway-cache/fixtures.car ' +ROOT1_CID=bafybeib3ffl2teiqdncv3mkz4r23b5ctrwkzrrhctdbne6iboayxuxk5ui # ./ +ROOT2_CID=bafybeih2w7hjocxjg6g2ku25hvmd53zj7og4txpby3vsusfefw5rrg5sii # ./root2 +ROOT3_CID=bafybeiawdvhmjcz65x5egzx4iukxc72hg4woks6v6fvgyupiyt3oczk5ja # ./root2/root3 +ROOT4_CID=bafybeifq2rzpqnqrsdupncmkmhs3ckxxjhuvdcbvydkgvch3ms24k5lo7q # ./root2/root3/root4 +FILE_CID=bafkreicysg23kiwv34eg2d7qweipxwosdo2py4ldv42nbauguluen5v6am # ./root2/root3/root4/index.html test_expect_success "Prepare IPNS unixfs content path for testing" ' TEST_IPNS_ID=$(ipfs key gen --ipns-base=base36 --type=ed25519 cache_test_key | head -n1 | tr -d "\n") diff --git a/test/sharness/t0116-gateway-cache/README.md b/test/sharness/t0116-gateway-cache/README.md new file mode 100644 index 00000000000..91c4389418d --- /dev/null +++ b/test/sharness/t0116-gateway-cache/README.md @@ -0,0 +1,30 @@ +# Dataset description/sources + +- fixtures.car + - raw CARv1 + +generated with: + +```sh +mkdir -p root2/root3/root4 && +echo "hello" > root2/root3/root4/index.html && +ROOT1_CID=$(ipfs add -Qrw --cid-version 1 root2) +ROOT2_CID=$(ipfs resolve -r /ipfs/$ROOT1_CID/root2 | cut -d "/" -f3) +ROOT3_CID=$(ipfs resolve -r /ipfs/$ROOT1_CID/root2/root3 | cut -d "/" -f3) +ROOT4_CID=$(ipfs resolve -r /ipfs/$ROOT1_CID/root2/root3/root4 | cut -d "/" -f3) +FILE_CID=$(ipfs resolve -r /ipfs/$ROOT1_CID/root2/root3/root4/index.html | cut -d "/" -f3) + +echo ROOT1_CID=${ROOT1_CID} +echo ROOT2_CID=${ROOT2_CID} +echo ROOT3_CID=${ROOT3_CID} +echo ROOT4_CID=${ROOT4_CID} +echo FILE_CID=${FILE_CID} + +ipfs dag export ${ROOT1_CID} > ./fixtures.car + +# ROOT1_CID=bafybeib3ffl2teiqdncv3mkz4r23b5ctrwkzrrhctdbne6iboayxuxk5ui # ./ +# ROOT2_CID=bafybeih2w7hjocxjg6g2ku25hvmd53zj7og4txpby3vsusfefw5rrg5sii # ./root2 +# ROOT3_CID=bafybeiawdvhmjcz65x5egzx4iukxc72hg4woks6v6fvgyupiyt3oczk5ja # ./root2/root3 +# ROOT4_CID=bafybeifq2rzpqnqrsdupncmkmhs3ckxxjhuvdcbvydkgvch3ms24k5lo7q # ./root2/root3/root4 +# FILE_CID=bafkreicysg23kiwv34eg2d7qweipxwosdo2py4ldv42nbauguluen5v6am # ./root2/root3/root4/index.html +``` diff --git a/test/sharness/t0116-gateway-cache/fixtures.car b/test/sharness/t0116-gateway-cache/fixtures.car new file mode 100644 index 0000000000000000000000000000000000000000..43e570e1d6acb0a03531b47feb540318f5027204 GIT binary patch literal 468 zcmcColvx?P5~W2SVzij7-;r*+x4)dz{ z2?vnLaUeGn)L{a2bEuF)#Kf&zm9F0B$mRdAQQ-H@OVV5Z6eh1XxzN Date: Mon, 20 Feb 2023 16:13:17 +0100 Subject: [PATCH 13/93] test: use car fixtures in sharness t0118 --- test/sharness/t0118-gateway-car.sh | 17 ++++++++-------- test/sharness/t0118-gateway-car/README.md | 19 ++++++++++++++++++ .../t0118-gateway-car/deterministic.car | Bin 0 -> 127 bytes .../t0118-gateway-car/subdir/ascii.txt | 1 + test/sharness/t0118-gateway-car/test-dag.car | Bin 0 -> 312 bytes 5 files changed, 28 insertions(+), 9 deletions(-) create mode 100644 test/sharness/t0118-gateway-car/deterministic.car create mode 100644 test/sharness/t0118-gateway-car/subdir/ascii.txt create mode 100644 test/sharness/t0118-gateway-car/test-dag.car diff --git a/test/sharness/t0118-gateway-car.sh b/test/sharness/t0118-gateway-car.sh index 62b2725d0cd..7b7d998eef8 100755 --- a/test/sharness/t0118-gateway-car.sh +++ b/test/sharness/t0118-gateway-car.sh @@ -11,15 +11,14 @@ test_launch_ipfs_daemon_without_network # but if we have a small file that fits into a single block, and export its CID # we will get a CAR that is a deterministic array of bytes. - test_expect_success "Create a deterministic CAR for testing" ' - mkdir -p subdir && - echo "hello application/vnd.ipld.car" > subdir/ascii.txt && - ROOT_DIR_CID=$(ipfs add -Qrw --cid-version 1 subdir) && - FILE_CID=$(ipfs resolve -r /ipfs/$ROOT_DIR_CID/subdir/ascii.txt | cut -d "/" -f3) && - ipfs dag export $ROOT_DIR_CID > test-dag.car && - ipfs dag export $FILE_CID > deterministic.car && - purge_blockstore - ' +# Import test case +# See the static fixtures in ./t0118-gateway-car/ +test_expect_success "Add the dir test directory" ' + cp ../t0118-gateway-car/test-dag.car ./test-dag.car && + cp ../t0118-gateway-car/deterministic.car ./deterministic.car +' +ROOT_DIR_CID=bafybeiefu3d7oytdumk5v7gn6s7whpornueaw7m7u46v2o6omsqcrhhkzi # ./ +FILE_CID=bafkreifkam6ns4aoolg3wedr4uzrs3kvq66p4pecirz6y2vlrngla62mxm # /subdir/ascii.txt # GET a reference DAG with dag-cbor+dag-pb+raw blocks as CAR diff --git a/test/sharness/t0118-gateway-car/README.md b/test/sharness/t0118-gateway-car/README.md index 2efccc18544..f19494833c5 100644 --- a/test/sharness/t0118-gateway-car/README.md +++ b/test/sharness/t0118-gateway-car/README.md @@ -8,3 +8,22 @@ - description of the contents and layout of the raw CAR, encoded in DAG-JSON - Source: https://ipld.io/specs/transport/car/fixture/carv1-basic/carv1-basic.json +- test-dag.car + deterministic.car + - raw CARv1 + +generated with: + +```shell +mkdir -p subdir && +echo "hello application/vnd.ipld.car" > subdir/ascii.txt && +ROOT_DIR_CID=$(ipfs add -Qrw --cid-version 1 subdir) && +FILE_CID=$(ipfs resolve -r /ipfs/$ROOT_DIR_CID/subdir/ascii.txt | cut -d "/" -f3) && +ipfs dag export $ROOT_DIR_CID > test-dag.car && +ipfs dag export $FILE_CID > deterministic.car && + +echo ROOT_DIR_CID=${ROOT_DIR_CID} # ./ +echo FILE_CID=${FILE_CID} # /\subdir/ascii.txt + +# ROOT_DIR_CID=bafybeiefu3d7oytdumk5v7gn6s7whpornueaw7m7u46v2o6omsqcrhhkzi # ./ +# FILE_CID=bafkreifkam6ns4aoolg3wedr4uzrs3kvq66p4pecirz6y2vlrngla62mxm # /subdir/ascii.txt +``` diff --git a/test/sharness/t0118-gateway-car/deterministic.car b/test/sharness/t0118-gateway-car/deterministic.car new file mode 100644 index 0000000000000000000000000000000000000000..3967f909dce9b45cc3109ef1bccb0febfaf3c964 GIT binary patch literal 127 zcmcColvurnv%3WfpBhW%hPLndXVc_T{3dI4x6g)Z xpWW$YsYS(^`FV`a#Hh|l&B@7ENGvGG$xKcx0cz7P%S+MAEXYaGOHM4}0stv?G@1Ya literal 0 HcmV?d00001 diff --git a/test/sharness/t0118-gateway-car/subdir/ascii.txt b/test/sharness/t0118-gateway-car/subdir/ascii.txt new file mode 100644 index 00000000000..a2f1a843bba --- /dev/null +++ b/test/sharness/t0118-gateway-car/subdir/ascii.txt @@ -0,0 +1 @@ +hello application/vnd.ipld.car diff --git a/test/sharness/t0118-gateway-car/test-dag.car b/test/sharness/t0118-gateway-car/test-dag.car new file mode 100644 index 0000000000000000000000000000000000000000..e80fa4b0756cb7c9f5ebc44242424506fb7283cb GIT binary patch literal 312 zcmcColv^5u?@7svMQ{B%`(=Of-ix^$+_m$U+s0a-OIe^X z=hdn7vecsD%=|pYC}LC#8E~n9)Saw+P!{lU+i#stX^z~mrGeJ6Qa_#6abJ&?`ByJ= zomD}It++HPC9_B(f{TfRF_tJT#z3P(g%nmX+uSVRD>}Pdpzx`&WNv8to_{t?F2!%M zR(JbssP@?{#FH}E7+o2uIXU?Xi3J5YnaPPIK>zBO<)!Fl7UZPp JB_|ef0RZo3fVKbt literal 0 HcmV?d00001 From a57ca965c1c6923efb7b11134dc6fc92d10960fa Mon Sep 17 00:00:00 2001 From: Laurent Senta Date: Mon, 20 Feb 2023 16:17:50 +0100 Subject: [PATCH 14/93] test: use car fixtures in sharness t0122 --- test/sharness/t0122-gateway-tar.sh | 22 ++++------- test/sharness/t0122-gateway-tar/README.md | 37 ++++++++++++++++++ test/sharness/t0122-gateway-tar/fixtures.car | Bin 0 -> 1053 bytes .../inside-root.car | Bin .../outside-root.car | Bin 5 files changed, 45 insertions(+), 14 deletions(-) create mode 100644 test/sharness/t0122-gateway-tar/README.md create mode 100644 test/sharness/t0122-gateway-tar/fixtures.car rename test/sharness/{t0122-gateway-tar-data => t0122-gateway-tar}/inside-root.car (100%) rename test/sharness/{t0122-gateway-tar-data => t0122-gateway-tar}/outside-root.car (100%) diff --git a/test/sharness/t0122-gateway-tar.sh b/test/sharness/t0122-gateway-tar.sh index 34dc1ba12c8..20cc1bf4cdc 100755 --- a/test/sharness/t0122-gateway-tar.sh +++ b/test/sharness/t0122-gateway-tar.sh @@ -10,20 +10,14 @@ test_launch_ipfs_daemon_without_network OUTSIDE_ROOT_CID="bafybeicaj7kvxpcv4neaqzwhrqqmdstu4dhrwfpknrgebq6nzcecfucvyu" INSIDE_ROOT_CID="bafybeibfevfxlvxp5vxobr5oapczpf7resxnleb7tkqmdorc4gl5cdva3y" +# Import test case +# See the static fixtures in ./t0122-gateway-tar/ test_expect_success "Add the test directory" ' - mkdir -p rootDir/ipfs && - mkdir -p rootDir/ipns && - mkdir -p rootDir/api && - mkdir -p rootDir/ą/ę && - echo "I am a txt file on path with utf8" > rootDir/ą/ę/file-źł.txt && - echo "I am a txt file in confusing /api dir" > rootDir/api/file.txt && - echo "I am a txt file in confusing /ipfs dir" > rootDir/ipfs/file.txt && - echo "I am a txt file in confusing /ipns dir" > rootDir/ipns/file.txt && - DIR_CID=$(ipfs add -Qr --cid-version 1 rootDir) && - FILE_CID=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/file-źł.txt | jq -r .Hash) && - FILE_SIZE=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/file-źł.txt | jq -r .Size) - echo "$FILE_CID / $FILE_SIZE" + ipfs dag import ../t0122-gateway-tar/fixtures.car ' +DIR_CID=bafybeig6ka5mlwkl4subqhaiatalkcleo4jgnr3hqwvpmsqfca27cijp3i # ./rootDir +FILE_CID=bafkreialihlqnf5uwo4byh4n3cmwlntwqzxxs2fg5vanqdi3d7tb2l5xkm # ./rootDir/ą/ę/file-źł.txt +FILE_SIZE=34 test_expect_success "GET TAR with format=tar and extract" ' curl "http://127.0.0.1:$GWAY_PORT/ipfs/$FILE_CID?format=tar" | tar -x @@ -69,9 +63,9 @@ test_expect_success "GET TAR with explicit ?filename= succeeds with modified Con " test_expect_success "Add CARs with relative paths to test with" ' - ipfs dag import ../t0122-gateway-tar-data/outside-root.car > import_output && + ipfs dag import ../t0122-gateway-tar/outside-root.car > import_output && test_should_contain $OUTSIDE_ROOT_CID import_output && - ipfs dag import ../t0122-gateway-tar-data/inside-root.car > import_output && + ipfs dag import ../t0122-gateway-tar/inside-root.car > import_output && test_should_contain $INSIDE_ROOT_CID import_output ' diff --git a/test/sharness/t0122-gateway-tar/README.md b/test/sharness/t0122-gateway-tar/README.md new file mode 100644 index 00000000000..8b9311277cc --- /dev/null +++ b/test/sharness/t0122-gateway-tar/README.md @@ -0,0 +1,37 @@ +# Dataset description/sources + +- inside-root.car + +- outside-root.car + +- fixtures.car + - raw CARv1 + +generated with: + +```sh +# ipfs version 0.18.1 + +mkdir -p rootDir/ipfs && +mkdir -p rootDir/ipns && +mkdir -p rootDir/api && +mkdir -p rootDir/ą/ę && +echo "I am a txt file on path with utf8" > rootDir/ą/ę/file-źł.txt && +echo "I am a txt file in confusing /api dir" > rootDir/api/file.txt && +echo "I am a txt file in confusing /ipfs dir" > rootDir/ipfs/file.txt && +echo "I am a txt file in confusing /ipns dir" > rootDir/ipns/file.txt && +DIR_CID=$(ipfs add -Qr --cid-version 1 rootDir) && +FILE_CID=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/file-źł.txt | jq -r .Hash) && +FILE_SIZE=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/file-źł.txt | jq -r .Size) +echo "$FILE_CID / $FILE_SIZE" + +echo DIR_CID=${DIR_CID} # ./rootDir +echo FILE_CID=${FILE_CID} # ./rootDir/ą/ę/file-źł.txt +echo FILE_SIZE=${FILE_SIZE} + +ipfs dag export ${DIR_CID} > ./fixtures.car + +# DIR_CID=bafybeig6ka5mlwkl4subqhaiatalkcleo4jgnr3hqwvpmsqfca27cijp3i # ./rootDir +# FILE_CID=bafkreialihlqnf5uwo4byh4n3cmwlntwqzxxs2fg5vanqdi3d7tb2l5xkm # ./rootDir/ą/ę/file-źł.txt +# FILE_SIZE=34 +``` diff --git a/test/sharness/t0122-gateway-tar/fixtures.car b/test/sharness/t0122-gateway-tar/fixtures.car new file mode 100644 index 0000000000000000000000000000000000000000..71a5603822741f25320438bd70823589120e313c GIT binary patch literal 1053 zcmcColvR$Z!{1TqeSN@tUjjg{Tlgc7mrAdS5w!gPn*17KH6I(#F3Vnld4xzQ6ixRGTe(8O`Zyg zxeAF2KuroD-3pm`3d#9-X{E)PdFcxJz;IJY$t>amyOUtJLEZWM>i;({85gv-W(d_V zKa@*2eN@-d)vWbj%$Z-NzS6vINbXbzxziiuPC}aSyAu>)2!|4kFsMU?&s>>u#q@K) zg=4JD+Ddu%u4<)wm#M_8IM$cG*3(nQFic@T$&fnuIuO3{I&*k2EHJEuD( zXEu8GPP(?~NTtQ!*2R(r|4!eUF1UKJ@frzWikc}A4+_gfkg)`nn?n*5x8rrT>037M zkdg1bF*9{rSzCT(#hs2>E#m S1&JjY3gwwVqO>H Date: Mon, 20 Feb 2023 16:24:57 +0100 Subject: [PATCH 15/93] test: use car fixtures in sharness t0123 --- test/sharness/t0123-gateway-json-cbor.sh | 21 +++------ .../t0123-gateway-json-cbor/README.md | 43 ++++++++++++++++++ .../t0123-gateway-json-cbor/fixtures.car | Bin 0 -> 1179 bytes 3 files changed, 50 insertions(+), 14 deletions(-) create mode 100644 test/sharness/t0123-gateway-json-cbor/README.md create mode 100644 test/sharness/t0123-gateway-json-cbor/fixtures.car diff --git a/test/sharness/t0123-gateway-json-cbor.sh b/test/sharness/t0123-gateway-json-cbor.sh index 704d075f940..b22c056de78 100755 --- a/test/sharness/t0123-gateway-json-cbor.sh +++ b/test/sharness/t0123-gateway-json-cbor.sh @@ -7,22 +7,15 @@ test_description="Test HTTP Gateway DAG-JSON (application/vnd.ipld.dag-json) and test_init_ipfs test_launch_ipfs_daemon_without_network +# Import test case +# See the static fixtures in ./t0123-gateway-json-cbor/ test_expect_success "Add the test directory" ' - mkdir -p rootDir/ipfs && - mkdir -p rootDir/ipns && - mkdir -p rootDir/api && - mkdir -p rootDir/ą/ę && - echo "{ \"test\": \"i am a plain json file\" }" > rootDir/ą/ę/t.json && - echo "I am a txt file on path with utf8" > rootDir/ą/ę/file-źł.txt && - echo "I am a txt file in confusing /api dir" > rootDir/api/file.txt && - echo "I am a txt file in confusing /ipfs dir" > rootDir/ipfs/file.txt && - echo "I am a txt file in confusing /ipns dir" > rootDir/ipns/file.txt && - DIR_CID=$(ipfs add -Qr --cid-version 1 rootDir) && - FILE_JSON_CID=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/t.json | jq -r .Hash) && - FILE_CID=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/file-źł.txt | jq -r .Hash) && - FILE_SIZE=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/file-źł.txt | jq -r .Size) - echo "$FILE_CID / $FILE_SIZE" + ipfs dag import ../t0123-gateway-json-cbor/fixtures.car ' +DIR_CID=bafybeiafyvqlazbbbtjnn6how5d6h6l6rxbqc4qgpbmteaiskjrffmyy4a # ./rootDir +FILE_JSON_CID=bafkreibrppizs3g7axs2jdlnjua6vgpmltv7k72l7v7sa6mmht6mne3qqe # ./rootDir/ą/ę/t.json +FILE_CID=bafkreialihlqnf5uwo4byh4n3cmwlntwqzxxs2fg5vanqdi3d7tb2l5xkm # ./rootDir/ą/ę/file-źł.txt +FILE_SIZE=34 ## Quick regression check for JSON stored on UnixFS: ## it has nothing to do with DAG-JSON and JSON codecs, diff --git a/test/sharness/t0123-gateway-json-cbor/README.md b/test/sharness/t0123-gateway-json-cbor/README.md new file mode 100644 index 00000000000..0d9f0e1e196 --- /dev/null +++ b/test/sharness/t0123-gateway-json-cbor/README.md @@ -0,0 +1,43 @@ +# Dataset description/sources + +- dag-cbor-traversal.car + +- dag-json-traversal.car + +- dag-pb.car + +- dag-pb.json + +- fixtures.car + - raw CARv1 + +generated with: + +```sh +mkdir -p rootDir/ipfs && +mkdir -p rootDir/ipns && +mkdir -p rootDir/api && +mkdir -p rootDir/ą/ę && +echo "{ \"test\": \"i am a plain json file\" }" > rootDir/ą/ę/t.json && +echo "I am a txt file on path with utf8" > rootDir/ą/ę/file-źł.txt && +echo "I am a txt file in confusing /api dir" > rootDir/api/file.txt && +echo "I am a txt file in confusing /ipfs dir" > rootDir/ipfs/file.txt && +echo "I am a txt file in confusing /ipns dir" > rootDir/ipns/file.txt && +DIR_CID=$(ipfs add -Qr --cid-version 1 rootDir) && +FILE_JSON_CID=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/t.json | jq -r .Hash) && +FILE_CID=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/file-źł.txt | jq -r .Hash) && +FILE_SIZE=$(ipfs files stat --enc=json /ipfs/$DIR_CID/ą/ę/file-źł.txt | jq -r .Size) +echo "$FILE_CID / $FILE_SIZE" + +echo DIR_CID=${DIR_CID} # ./rootDir +echo FILE_JSON_CID=${FILE_JSON_CID} # ./rootDir/ą/ę/t.json +echo FILE_CID=${FILE_CID} # ./rootDir/ą/ę/file-źł.txt +echo FILE_SIZE=${FILE_SIZE} + +ipfs dag export ${DIR_CID} > fixtures.car + +# DIR_CID=bafybeiafyvqlazbbbtjnn6how5d6h6l6rxbqc4qgpbmteaiskjrffmyy4a # ./rootDir +# FILE_JSON_CID=bafkreibrppizs3g7axs2jdlnjua6vgpmltv7k72l7v7sa6mmht6mne3qqe # ./rootDir/ą/ę/t.json +# FILE_CID=bafkreialihlqnf5uwo4byh4n3cmwlntwqzxxs2fg5vanqdi3d7tb2l5xkm # ./rootDir/ą/ę/file-źł.txt +# FILE_SIZE=34 +``` diff --git a/test/sharness/t0123-gateway-json-cbor/fixtures.car b/test/sharness/t0123-gateway-json-cbor/fixtures.car new file mode 100644 index 0000000000000000000000000000000000000000..8663730f2fed608271d33fd2e205c68d544e89b7 GIT binary patch literal 1179 zcmcColvR$Z!{1Tq}`!({@E*_B@ucod~pEh~Fe6+Vnh$AgCCsnVcqC`RsWVjbGnmiQ} za}^R5fSMFQx)n0>6q57v(n^an^U@Xcf#If*l3BzBb|=AbgSzwi)&Fl^GA?Lu%@C?# zekhl4`lzm@t6A&6m@~gjeWiKbkld*ba;G=QorE;ucPA*q5Dq06VNiz(pSd#Sis|Qo z3&&WQwUzSjUDZnWE>nqFajY+Wv%U0UCaex6q=}G2^B@il2gN+Wlmbmr3p)>Tspfra zzuq^&%Z+8;aog1@_L@tNFW#`M%_oCfEfAQZW=d=Wr>M!`oI_B9IV4GOJ6>m-zGd?c z8TsBDGgG&fwdGf4EPLy4gI8MqnXLZyU?E;mqR>6M>u3`=T`36}Kr|XwU!0k9pY`dI z-dtbCS2N$ly#8A6{kLABvd8AnvB?FELTn{^S;hHz5~`pWb_2yQA-m86EKFpafyI_VZ5QMu0#h}}HQ*$!q)^KR00zs~cmMzZ literal 0 HcmV?d00001 From 3ed8f394e00fb3a7dc18af567b04512db51e6dbb Mon Sep 17 00:00:00 2001 From: Laurent Senta Date: Mon, 20 Feb 2023 16:45:28 +0100 Subject: [PATCH 16/93] test: use car fixtures in sharness t0400 --- test/sharness/t0400-api-no-gateway.sh | 9 +++++++-- test/sharness/t0400-api-no-gateway/README.md | 15 +++++++++++++++ test/sharness/t0400-api-no-gateway/fixtures.car | Bin 0 -> 108 bytes 3 files changed, 22 insertions(+), 2 deletions(-) create mode 100644 test/sharness/t0400-api-no-gateway/README.md create mode 100644 test/sharness/t0400-api-no-gateway/fixtures.car diff --git a/test/sharness/t0400-api-no-gateway.sh b/test/sharness/t0400-api-no-gateway.sh index 137f99a950e..d0daeece3da 100755 --- a/test/sharness/t0400-api-no-gateway.sh +++ b/test/sharness/t0400-api-no-gateway.sh @@ -10,6 +10,13 @@ test_description="Test API security" test_init_ipfs +# Import test case +# See the static fixtures in ./t0400-api-no-gateway/ +test_expect_success "Add the test directory" ' + ipfs dag import ../t0400-api-no-gateway/fixtures.car +' +HASH=QmNYERzV2LfD2kkfahtfv44ocHzEFK1sLBaE7zdcYT2GAZ # a file containing the string "testing" + # by default, we don't let you load arbitrary ipfs objects through the api, # because this would open up the api to scripting vulnerabilities. # only the webui objects are allowed. @@ -17,14 +24,12 @@ test_init_ipfs test_launch_ipfs_daemon test_expect_success "Gateway on API unavailable" ' - HASH=$(echo "testing" | ipfs add -q) test_curl_resp_http_code "http://127.0.0.1:$API_PORT/ipfs/$HASH" "HTTP/1.1 404 Not Found" ' test_kill_ipfs_daemon test_launch_ipfs_daemon --unrestricted-api test_expect_success "Gateway on --unrestricted-api API available" ' - HASH=$(echo "testing" | ipfs add -q) test_curl_resp_http_code "http://127.0.0.1:$API_PORT/ipfs/$HASH" "HTTP/1.1 200 OK" ' test_kill_ipfs_daemon diff --git a/test/sharness/t0400-api-no-gateway/README.md b/test/sharness/t0400-api-no-gateway/README.md new file mode 100644 index 00000000000..83d184d4a42 --- /dev/null +++ b/test/sharness/t0400-api-no-gateway/README.md @@ -0,0 +1,15 @@ +# Dataset description/sources + +- fixtures.car + - raw CARv1 + +generated with: + +```sh +HASH=$(echo "testing" | ipfs add -q) +ipfs dag export $HASH > fixtures.car + +echo HASH=${HASH} # a file containing the string "testing" + +# HASH=QmNYERzV2LfD2kkfahtfv44ocHzEFK1sLBaE7zdcYT2GAZ # a file containing the string "testing" +``` diff --git a/test/sharness/t0400-api-no-gateway/fixtures.car b/test/sharness/t0400-api-no-gateway/fixtures.car new file mode 100644 index 0000000000000000000000000000000000000000..1e090db6dc1e7d3a07c8523de752e61dc744bd1f GIT binary patch literal 108 zcmcCmlv Date: Thu, 23 Feb 2023 11:42:51 +0100 Subject: [PATCH 17/93] fix: add versions --- test/sharness/t0113-gateway-symlink/README.md | 1 + test/sharness/t0114-gateway-subdomains/README.md | 2 ++ test/sharness/t0115-gateway-dir-listing/README.md | 1 + test/sharness/t0116-gateway-cache/README.md | 1 + test/sharness/t0117-gateway-block/README.md | 1 + test/sharness/t0118-gateway-car/README.md | 3 ++- test/sharness/t0123-gateway-json-cbor/README.md | 1 + test/sharness/t0400-api-no-gateway/README.md | 1 + 8 files changed, 10 insertions(+), 1 deletion(-) diff --git a/test/sharness/t0113-gateway-symlink/README.md b/test/sharness/t0113-gateway-symlink/README.md index 350405e321b..31a257bdded 100644 --- a/test/sharness/t0113-gateway-symlink/README.md +++ b/test/sharness/t0113-gateway-symlink/README.md @@ -6,6 +6,7 @@ generated with: ```sh +# using ipfs version 0.18.1 mkdir testfiles && echo "content" > testfiles/foo && ln -s foo testfiles/bar && diff --git a/test/sharness/t0114-gateway-subdomains/README.md b/test/sharness/t0114-gateway-subdomains/README.md index 8f0075ccd7e..611bd0ed5ad 100644 --- a/test/sharness/t0114-gateway-subdomains/README.md +++ b/test/sharness/t0114-gateway-subdomains/README.md @@ -6,6 +6,8 @@ generated with: ```sh +# using ipfs version 0.18.1 + # CIDv0to1 is necessary because raw-leaves are enabled by default during # "ipfs add" with CIDv1 and disabled with CIDv0 CID_VAL="hello" diff --git a/test/sharness/t0115-gateway-dir-listing/README.md b/test/sharness/t0115-gateway-dir-listing/README.md index 8b6e332750d..937438bcd65 100644 --- a/test/sharness/t0115-gateway-dir-listing/README.md +++ b/test/sharness/t0115-gateway-dir-listing/README.md @@ -6,6 +6,7 @@ generated with: ```sh +# using ipfs version 0.18.1 mkdir -p rootDir/ipfs && mkdir -p rootDir/ipns && mkdir -p rootDir/api && diff --git a/test/sharness/t0116-gateway-cache/README.md b/test/sharness/t0116-gateway-cache/README.md index 91c4389418d..8b44fe640b7 100644 --- a/test/sharness/t0116-gateway-cache/README.md +++ b/test/sharness/t0116-gateway-cache/README.md @@ -6,6 +6,7 @@ generated with: ```sh +# using ipfs version 0.18.1 mkdir -p root2/root3/root4 && echo "hello" > root2/root3/root4/index.html && ROOT1_CID=$(ipfs add -Qrw --cid-version 1 root2) diff --git a/test/sharness/t0117-gateway-block/README.md b/test/sharness/t0117-gateway-block/README.md index 8ca237345a7..4ce37ae086f 100644 --- a/test/sharness/t0117-gateway-block/README.md +++ b/test/sharness/t0117-gateway-block/README.md @@ -6,6 +6,7 @@ generated with: ```sh +# using ipfs version 0.18.1 mkdir -p dir && echo "hello application/vnd.ipld.raw" > dir/ascii.txt && ROOT_DIR_CID=$(ipfs add -Qrw --cid-version 1 dir) && diff --git a/test/sharness/t0118-gateway-car/README.md b/test/sharness/t0118-gateway-car/README.md index f19494833c5..7b81e543bc1 100644 --- a/test/sharness/t0118-gateway-car/README.md +++ b/test/sharness/t0118-gateway-car/README.md @@ -13,7 +13,8 @@ generated with: -```shell +```sh +# using ipfs version 0.18.1 mkdir -p subdir && echo "hello application/vnd.ipld.car" > subdir/ascii.txt && ROOT_DIR_CID=$(ipfs add -Qrw --cid-version 1 subdir) && diff --git a/test/sharness/t0123-gateway-json-cbor/README.md b/test/sharness/t0123-gateway-json-cbor/README.md index 0d9f0e1e196..4e83f42a161 100644 --- a/test/sharness/t0123-gateway-json-cbor/README.md +++ b/test/sharness/t0123-gateway-json-cbor/README.md @@ -14,6 +14,7 @@ generated with: ```sh +# using ipfs version 0.18.1 mkdir -p rootDir/ipfs && mkdir -p rootDir/ipns && mkdir -p rootDir/api && diff --git a/test/sharness/t0400-api-no-gateway/README.md b/test/sharness/t0400-api-no-gateway/README.md index 83d184d4a42..32222d41b84 100644 --- a/test/sharness/t0400-api-no-gateway/README.md +++ b/test/sharness/t0400-api-no-gateway/README.md @@ -6,6 +6,7 @@ generated with: ```sh +# using ipfs version 0.18.1 HASH=$(echo "testing" | ipfs add -q) ipfs dag export $HASH > fixtures.car From 92a068a82b74e453c4afea37ec4b0f3155b0d248 Mon Sep 17 00:00:00 2001 From: Laurent Senta Date: Mon, 27 Feb 2023 11:21:02 +0100 Subject: [PATCH 18/93] fix: remove leftover fixtures & notes --- test/sharness/t0113-gateway-symlink.sh | 1 - test/sharness/t0118-gateway-car/subdir/ascii.txt | 1 - 2 files changed, 2 deletions(-) delete mode 100644 test/sharness/t0118-gateway-car/subdir/ascii.txt diff --git a/test/sharness/t0113-gateway-symlink.sh b/test/sharness/t0113-gateway-symlink.sh index ea85b815000..29e5b960de3 100755 --- a/test/sharness/t0113-gateway-symlink.sh +++ b/test/sharness/t0113-gateway-symlink.sh @@ -22,7 +22,6 @@ test_expect_success "Test the directory listing" ' test_should_contain ">bar<" list_response ' -# TODO: it's unclear to me if that `echo -n "foo" > expected` should be a fixture somehow. test_expect_success "Test the symlink" ' curl "$GWAY_ADDR/ipfs/$ROOT_DIR_CID/bar" > bar_actual && echo -n "foo" > bar_expected && diff --git a/test/sharness/t0118-gateway-car/subdir/ascii.txt b/test/sharness/t0118-gateway-car/subdir/ascii.txt deleted file mode 100644 index a2f1a843bba..00000000000 --- a/test/sharness/t0118-gateway-car/subdir/ascii.txt +++ /dev/null @@ -1 +0,0 @@ -hello application/vnd.ipld.car From baa9d609ec808b7c77ac98da62244444c2827fc7 Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Mon, 27 Feb 2023 13:18:11 +0100 Subject: [PATCH 19/93] ci: get rid of interop matrix --- .github/workflows/build.yml | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index c7c17a43e1f..5e607b5ed38 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -40,13 +40,6 @@ jobs: ipfs-interop: needs: [prepare] runs-on: ubuntu-latest - strategy: - matrix: - include: - - patterns: 'exchange-files' - - patterns: 'exchange-files' - options: '-v' - fail-fast: false defaults: run: shell: bash @@ -75,7 +68,7 @@ jobs: npm install kubo-rpc-client@^3.0.1 npm install ipfs-interop@^10.0.1 working-directory: interop - - run: npx ipfs-interop -- -t node $(ls node_modules/ipfs-interop/test/*.js | grep ${{ matrix.options }} '${{ matrix.patterns }}' | sed -e 's;node_modules/ipfs-interop/;-f ;' | tr '\n' ' ') + - run: npx ipfs-interop -- -t node env: LIBP2P_TCP_REUSEPORT: false LIBP2P_ALLOW_WEAK_RSA_KEYS: 1 From e3b17a4fe6fa584ca97bdee21bb1b5ab36a1a27b Mon Sep 17 00:00:00 2001 From: Gabe <7622243+decentralgabe@users.noreply.github.com> Date: Mon, 27 Feb 2023 06:43:20 -0800 Subject: [PATCH 20/93] docs: be clear about swarm.addrfilters (#9661) --- docs/config.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/config.md b/docs/config.md index 3bc558e88ad..76a49ba03e0 100644 --- a/docs/config.md +++ b/docs/config.md @@ -1542,9 +1542,9 @@ another node, even if this other node is on a different network. This may trigger netscan alerts on some hosting providers or cause strain in some setups. The `server` configuration profile fills up this list with sensible defaults, -preventing dials to all non-routable IP addresses (e.g., `192.168.0.0/16`) but -you should always check settings against your own network and/or hosting -provider. +preventing dials to all non-routable IP addresses (e.g., `/ip4/192.168.0.0/ipcidr/16`, +which is the multiaddress representation of `192.168.0.0/16`) but you should always +check settings against your own network and/or hosting provider. Default: `[]` From 1794649bf2d4f8f1607a67f25632053a4d873617 Mon Sep 17 00:00:00 2001 From: Henrique Dias Date: Tue, 28 Feb 2023 02:21:50 +0100 Subject: [PATCH 21/93] feat(gateway): error handling improvements (500, 502, 504) (#9660) * fix(gateway): return 500 for all /ip[nf]s/id failures * fix: replace deprecated structs * chore: bump go-libipfs to version from main --- core/commands/bitswap.go | 6 +++--- docs/examples/kubo-as-a-library/go.mod | 4 ++-- docs/examples/kubo-as-a-library/go.sum | 8 ++++---- go.mod | 4 ++-- go.sum | 8 ++++---- test/cli/gateway_test.go | 10 +++++----- 6 files changed, 20 insertions(+), 20 deletions(-) diff --git a/core/commands/bitswap.go b/core/commands/bitswap.go index a7e8965b1f2..51c2f916dee 100644 --- a/core/commands/bitswap.go +++ b/core/commands/bitswap.go @@ -11,7 +11,7 @@ import ( cidutil "github.com/ipfs/go-cidutil" cmds "github.com/ipfs/go-ipfs-cmds" bitswap "github.com/ipfs/go-libipfs/bitswap" - decision "github.com/ipfs/go-libipfs/bitswap/decision" + "github.com/ipfs/go-libipfs/bitswap/server" peer "github.com/libp2p/go-libp2p/core/peer" ) @@ -179,7 +179,7 @@ prints the ledger associated with a given peer. Arguments: []cmds.Argument{ cmds.StringArg("peer", true, false, "The PeerID (B58) of the ledger to inspect."), }, - Type: decision.Receipt{}, + Type: server.Receipt{}, Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error { nd, err := cmdenv.GetNode(env) if err != nil { @@ -203,7 +203,7 @@ prints the ledger associated with a given peer. return cmds.EmitOnce(res, bs.LedgerForPeer(partner)) }, Encoders: cmds.EncoderMap{ - cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *decision.Receipt) error { + cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *server.Receipt) error { fmt.Fprintf(w, "Ledger for %s\n"+ "Debt ratio:\t%f\n"+ "Exchanges:\t%d\n"+ diff --git a/docs/examples/kubo-as-a-library/go.mod b/docs/examples/kubo-as-a-library/go.mod index d0a229424a3..ed2e7a1db85 100644 --- a/docs/examples/kubo-as-a-library/go.mod +++ b/docs/examples/kubo-as-a-library/go.mod @@ -7,7 +7,7 @@ go 1.18 replace github.com/ipfs/kubo => ./../../.. require ( - github.com/ipfs/go-libipfs v0.6.1-0.20230222011044-7b201415a176 + github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 github.com/ipfs/interface-go-ipfs-core v0.11.0 github.com/ipfs/kubo v0.0.0-00010101000000-000000000000 github.com/libp2p/go-libp2p v0.26.0 @@ -101,7 +101,7 @@ require ( github.com/ipfs/go-metrics-interface v0.0.1 // indirect github.com/ipfs/go-mfs v0.2.1 // indirect github.com/ipfs/go-namesys v0.7.0 // indirect - github.com/ipfs/go-path v0.3.0 // indirect + github.com/ipfs/go-path v0.3.1 // indirect github.com/ipfs/go-peertaskqueue v0.8.1 // indirect github.com/ipfs/go-unixfs v0.4.3 // indirect github.com/ipfs/go-unixfsnode v1.5.2 // indirect diff --git a/docs/examples/kubo-as-a-library/go.sum b/docs/examples/kubo-as-a-library/go.sum index 6a5ee23962d..17793a3ff7c 100644 --- a/docs/examples/kubo-as-a-library/go.sum +++ b/docs/examples/kubo-as-a-library/go.sum @@ -569,8 +569,8 @@ github.com/ipfs/go-ipld-legacy v0.1.1 h1:BvD8PEuqwBHLTKqlGFTHSwrwFOMkVESEvwIYwR2 github.com/ipfs/go-ipld-legacy v0.1.1/go.mod h1:8AyKFCjgRPsQFf15ZQgDB8Din4DML/fOmKZkkFkrIEg= github.com/ipfs/go-ipns v0.3.0 h1:ai791nTgVo+zTuq2bLvEGmWP1M0A6kGTXUsgv/Yq67A= github.com/ipfs/go-ipns v0.3.0/go.mod h1:3cLT2rbvgPZGkHJoPO1YMJeh6LtkxopCkKFcio/wE24= -github.com/ipfs/go-libipfs v0.6.1-0.20230222011044-7b201415a176 h1:QJvWxLRKucrAo7W2vLz5FA2iLKwW6WkHWn8AL8kXAUU= -github.com/ipfs/go-libipfs v0.6.1-0.20230222011044-7b201415a176/go.mod h1:UjjDIuehp2GzlNP0HEr5I9GfFT7zWgst+YfpUEIThtw= +github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 h1:QRLcCoITO9ZQo2pvjmrfngqKhUKjPopBva3MVH62LT8= +github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260/go.mod h1:3OoEQs95UkqFEf65SbRDpiMwuzI+C/jTsYQaHfBbJXI= github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk= github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A= @@ -598,8 +598,8 @@ github.com/ipfs/go-mfs v0.2.1/go.mod h1:Woj80iuw4ajDnIP6+seRaoHpPsc9hmL0pk/nDNDW github.com/ipfs/go-namesys v0.7.0 h1:xqosk71GIVRkFDtF2UNRcXn4LdNeo7tzuy8feHD6NbU= github.com/ipfs/go-namesys v0.7.0/go.mod h1:KYSZBVZG3VJC34EfqqJPG7T48aWgxseoMPAPA5gLyyQ= github.com/ipfs/go-path v0.2.1/go.mod h1:NOScsVgxfC/eIw4nz6OiGwK42PjaSJ4Y/ZFPn1Xe07I= -github.com/ipfs/go-path v0.3.0 h1:tkjga3MtpXyM5v+3EbRvOHEoo+frwi4oumw5K+KYWyA= -github.com/ipfs/go-path v0.3.0/go.mod h1:NOScsVgxfC/eIw4nz6OiGwK42PjaSJ4Y/ZFPn1Xe07I= +github.com/ipfs/go-path v0.3.1 h1:wkeaCWE/NTuuPGlEkLTsED5UkzfKYZpxaFFPgk8ZVLE= +github.com/ipfs/go-path v0.3.1/go.mod h1:eNLsxJEEMxn/CDzUJ6wuNl+6No6tEUhOZcPKsZsYX0E= github.com/ipfs/go-peertaskqueue v0.1.0/go.mod h1:Jmk3IyCcfl1W3jTW3YpghSwSEC6IJ3Vzz/jUmWw8Z0U= github.com/ipfs/go-peertaskqueue v0.7.0/go.mod h1:M/akTIE/z1jGNXMU7kFB4TeSEFvj68ow0Rrb04donIU= github.com/ipfs/go-peertaskqueue v0.8.1 h1:YhxAs1+wxb5jk7RvS0LHdyiILpNmRIRnZVztekOF0pg= diff --git a/go.mod b/go.mod index 00c464b9d3a..aae886177c2 100644 --- a/go.mod +++ b/go.mod @@ -45,7 +45,7 @@ require ( github.com/ipfs/go-ipld-git v0.1.1 github.com/ipfs/go-ipld-legacy v0.1.1 github.com/ipfs/go-ipns v0.3.0 - github.com/ipfs/go-libipfs v0.6.1-0.20230222011044-7b201415a176 + github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 github.com/ipfs/go-log v1.0.5 github.com/ipfs/go-log/v2 v2.5.1 github.com/ipfs/go-merkledag v0.9.0 @@ -53,7 +53,7 @@ require ( github.com/ipfs/go-metrics-prometheus v0.0.2 github.com/ipfs/go-mfs v0.2.1 github.com/ipfs/go-namesys v0.7.0 - github.com/ipfs/go-path v0.3.0 + github.com/ipfs/go-path v0.3.1 github.com/ipfs/go-pinning-service-http-client v0.1.2 github.com/ipfs/go-unixfs v0.4.3 github.com/ipfs/go-unixfsnode v1.5.2 diff --git a/go.sum b/go.sum index d650d704cff..93c9b97a4c1 100644 --- a/go.sum +++ b/go.sum @@ -591,8 +591,8 @@ github.com/ipfs/go-ipld-legacy v0.1.1 h1:BvD8PEuqwBHLTKqlGFTHSwrwFOMkVESEvwIYwR2 github.com/ipfs/go-ipld-legacy v0.1.1/go.mod h1:8AyKFCjgRPsQFf15ZQgDB8Din4DML/fOmKZkkFkrIEg= github.com/ipfs/go-ipns v0.3.0 h1:ai791nTgVo+zTuq2bLvEGmWP1M0A6kGTXUsgv/Yq67A= github.com/ipfs/go-ipns v0.3.0/go.mod h1:3cLT2rbvgPZGkHJoPO1YMJeh6LtkxopCkKFcio/wE24= -github.com/ipfs/go-libipfs v0.6.1-0.20230222011044-7b201415a176 h1:QJvWxLRKucrAo7W2vLz5FA2iLKwW6WkHWn8AL8kXAUU= -github.com/ipfs/go-libipfs v0.6.1-0.20230222011044-7b201415a176/go.mod h1:UjjDIuehp2GzlNP0HEr5I9GfFT7zWgst+YfpUEIThtw= +github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 h1:QRLcCoITO9ZQo2pvjmrfngqKhUKjPopBva3MVH62LT8= +github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260/go.mod h1:3OoEQs95UkqFEf65SbRDpiMwuzI+C/jTsYQaHfBbJXI= github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk= github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A= @@ -622,8 +622,8 @@ github.com/ipfs/go-mfs v0.2.1/go.mod h1:Woj80iuw4ajDnIP6+seRaoHpPsc9hmL0pk/nDNDW github.com/ipfs/go-namesys v0.7.0 h1:xqosk71GIVRkFDtF2UNRcXn4LdNeo7tzuy8feHD6NbU= github.com/ipfs/go-namesys v0.7.0/go.mod h1:KYSZBVZG3VJC34EfqqJPG7T48aWgxseoMPAPA5gLyyQ= github.com/ipfs/go-path v0.2.1/go.mod h1:NOScsVgxfC/eIw4nz6OiGwK42PjaSJ4Y/ZFPn1Xe07I= -github.com/ipfs/go-path v0.3.0 h1:tkjga3MtpXyM5v+3EbRvOHEoo+frwi4oumw5K+KYWyA= -github.com/ipfs/go-path v0.3.0/go.mod h1:NOScsVgxfC/eIw4nz6OiGwK42PjaSJ4Y/ZFPn1Xe07I= +github.com/ipfs/go-path v0.3.1 h1:wkeaCWE/NTuuPGlEkLTsED5UkzfKYZpxaFFPgk8ZVLE= +github.com/ipfs/go-path v0.3.1/go.mod h1:eNLsxJEEMxn/CDzUJ6wuNl+6No6tEUhOZcPKsZsYX0E= github.com/ipfs/go-peertaskqueue v0.1.0/go.mod h1:Jmk3IyCcfl1W3jTW3YpghSwSEC6IJ3Vzz/jUmWw8Z0U= github.com/ipfs/go-peertaskqueue v0.7.0/go.mod h1:M/akTIE/z1jGNXMU7kFB4TeSEFvj68ow0Rrb04donIU= github.com/ipfs/go-peertaskqueue v0.8.1 h1:YhxAs1+wxb5jk7RvS0LHdyiILpNmRIRnZVztekOF0pg= diff --git a/test/cli/gateway_test.go b/test/cli/gateway_test.go index 7139bef1b8a..a585925a763 100644 --- a/test/cli/gateway_test.go +++ b/test/cli/gateway_test.go @@ -126,10 +126,10 @@ func TestGateway(t *testing.T) { assert.Equal(t, 404, resp.StatusCode) }) - t.Run("GET IPFS invalid CID returns 400 (Bad Request)", func(t *testing.T) { + t.Run("GET IPFS invalid CID returns 500 (Internal Server Error)", func(t *testing.T) { t.Parallel() resp := client.Get("/ipfs/QmInvalid/pleaseDontAddMe") - assert.Equal(t, 400, resp.StatusCode) + assert.Equal(t, 500, resp.StatusCode) }) t.Run("GET IPFS inlined zero-length data object returns ok code (200)", func(t *testing.T) { @@ -166,10 +166,10 @@ func TestGateway(t *testing.T) { t.Parallel() node.IPFS("name", "publish", "--allow-offline", cid) - t.Run("GET invalid IPNS root returns 400 (Bad Request)", func(t *testing.T) { + t.Run("GET invalid IPNS root returns 500 (Internal Server Error)", func(t *testing.T) { t.Parallel() resp := client.Get("/ipns/QmInvalid/pleaseDontAddMe") - assert.Equal(t, 400, resp.StatusCode) + assert.Equal(t, 500, resp.StatusCode) }) t.Run("GET IPNS path succeeds", func(t *testing.T) { @@ -198,7 +198,7 @@ func TestGateway(t *testing.T) { t.Run("GET invalid IPFS path errors", func(t *testing.T) { t.Parallel() - assert.Equal(t, 400, client.Get("/ipfs/12345").StatusCode) + assert.Equal(t, 500, client.Get("/ipfs/12345").StatusCode) }) t.Run("GET invalid path errors", func(t *testing.T) { From 56b9962103ce5a56f15752374cd14541bc3297e9 Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Tue, 28 Feb 2023 10:25:25 +1300 Subject: [PATCH 22/93] chore: update go-libp2p to v0.26.1 --- docs/examples/kubo-as-a-library/go.mod | 6 +++--- docs/examples/kubo-as-a-library/go.sum | 12 ++++++------ go.mod | 6 +++--- go.sum | 12 ++++++------ 4 files changed, 18 insertions(+), 18 deletions(-) diff --git a/docs/examples/kubo-as-a-library/go.mod b/docs/examples/kubo-as-a-library/go.mod index ed2e7a1db85..77dc8403874 100644 --- a/docs/examples/kubo-as-a-library/go.mod +++ b/docs/examples/kubo-as-a-library/go.mod @@ -10,7 +10,7 @@ require ( github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 github.com/ipfs/interface-go-ipfs-core v0.11.0 github.com/ipfs/kubo v0.0.0-00010101000000-000000000000 - github.com/libp2p/go-libp2p v0.26.0 + github.com/libp2p/go-libp2p v0.26.1 github.com/multiformats/go-multiaddr v0.8.0 ) @@ -119,7 +119,7 @@ require ( github.com/libp2p/go-cidranger v1.1.0 // indirect github.com/libp2p/go-doh-resolver v0.4.0 // indirect github.com/libp2p/go-flow-metrics v0.1.0 // indirect - github.com/libp2p/go-libp2p-asn-util v0.2.0 // indirect + github.com/libp2p/go-libp2p-asn-util v0.3.0 // indirect github.com/libp2p/go-libp2p-kad-dht v0.21.1 // indirect github.com/libp2p/go-libp2p-kbucket v0.5.0 // indirect github.com/libp2p/go-libp2p-pubsub v0.9.0 // indirect @@ -167,7 +167,7 @@ require ( github.com/quic-go/qtls-go1-19 v0.2.1 // indirect github.com/quic-go/qtls-go1-20 v0.1.1 // indirect github.com/quic-go/quic-go v0.33.0 // indirect - github.com/quic-go/webtransport-go v0.5.1 // indirect + github.com/quic-go/webtransport-go v0.5.2 // indirect github.com/raulk/go-watchdog v1.3.0 // indirect github.com/samber/lo v1.36.0 // indirect github.com/spaolacci/murmur3 v1.1.0 // indirect diff --git a/docs/examples/kubo-as-a-library/go.sum b/docs/examples/kubo-as-a-library/go.sum index 17793a3ff7c..6e365b6a7c8 100644 --- a/docs/examples/kubo-as-a-library/go.sum +++ b/docs/examples/kubo-as-a-library/go.sum @@ -730,10 +730,10 @@ github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xS github.com/libp2p/go-libp2p v0.7.4/go.mod h1:oXsBlTLF1q7pxr+9w6lqzS1ILpyHsaBPniVO7zIHGMw= github.com/libp2p/go-libp2p v0.8.1/go.mod h1:QRNH9pwdbEBpx5DTJYg+qxcVaDMAz3Ee/qDKwXujH5o= github.com/libp2p/go-libp2p v0.14.3/go.mod h1:d12V4PdKbpL0T1/gsUNN8DfgMuRPDX8bS2QxCZlwRH0= -github.com/libp2p/go-libp2p v0.26.0 h1:0FE0bP9/G9YADjruqoFvf1snBBFvrdh1MmTuEeUkl2E= -github.com/libp2p/go-libp2p v0.26.0/go.mod h1:R8N+XhwPDPLNb4TKboKJKnDeg9vPw8+zlC6g793dTGw= -github.com/libp2p/go-libp2p-asn-util v0.2.0 h1:rg3+Os8jbnO5DxkC7K/Utdi+DkY3q/d1/1q+8WeNAsw= -github.com/libp2p/go-libp2p-asn-util v0.2.0/go.mod h1:WoaWxbHKBymSN41hWSq/lGKJEca7TNm58+gGJi2WsLI= +github.com/libp2p/go-libp2p v0.26.1 h1:I9bHj5KteIB1tsBWLT25TTttx5xSjun3ph/q/8Xax/k= +github.com/libp2p/go-libp2p v0.26.1/go.mod h1:HKQUKIQ5NhzabNMWq9Wczcs5Ksdx4LQ/ISAq4MRqBHQ= +github.com/libp2p/go-libp2p-asn-util v0.3.0 h1:gMDcMyYiZKkocGXDQ5nsUQyquC9+H+iLEQHwOCZ7s8s= +github.com/libp2p/go-libp2p-asn-util v0.3.0/go.mod h1:B1mcOrKUE35Xq/ASTmQ4tN3LNzVVaMNmq2NACuqyB9w= github.com/libp2p/go-libp2p-autonat v0.1.0/go.mod h1:1tLf2yXxiE/oKGtDwPYWTSYG3PtvYlJmg7NeVtPRqH8= github.com/libp2p/go-libp2p-autonat v0.1.1/go.mod h1:OXqkeGOY2xJVWKAGV2inNF5aKN/djNA3fdpCWloIudE= github.com/libp2p/go-libp2p-autonat v0.2.0/go.mod h1:DX+9teU4pEEoZUqR1PiMlqliONQdNbfzE1C718tcViI= @@ -1177,8 +1177,8 @@ github.com/quic-go/qtls-go1-20 v0.1.1 h1:KbChDlg82d3IHqaj2bn6GfKRj84Per2VGf5XV3w github.com/quic-go/qtls-go1-20 v0.1.1/go.mod h1:JKtK6mjbAVcUTN/9jZpvLbGxvdWIKS8uT7EiStoU1SM= github.com/quic-go/quic-go v0.33.0 h1:ItNoTDN/Fm/zBlq769lLJc8ECe9gYaW40veHCCco7y0= github.com/quic-go/quic-go v0.33.0/go.mod h1:YMuhaAV9/jIu0XclDXwZPAsP/2Kgr5yMYhe9oxhhOFA= -github.com/quic-go/webtransport-go v0.5.1 h1:1eVb7WDWCRoaeTtFHpFBJ6WDN1bSrPrRoW6tZgSw0Ow= -github.com/quic-go/webtransport-go v0.5.1/go.mod h1:OhmmgJIzTTqXK5xvtuX0oBpLV2GkLWNDA+UeTGJXErU= +github.com/quic-go/webtransport-go v0.5.2 h1:GA6Bl6oZY+g/flt00Pnu0XtivSD8vukOu3lYhJjnGEk= +github.com/quic-go/webtransport-go v0.5.2/go.mod h1:OhmmgJIzTTqXK5xvtuX0oBpLV2GkLWNDA+UeTGJXErU= github.com/rabbitmq/amqp091-go v1.1.0/go.mod h1:ogQDLSOACsLPsIq0NpbtiifNZi2YOz0VTJ0kHRghqbM= github.com/raulk/go-watchdog v1.3.0 h1:oUmdlHxdkXRJlwfG0O9omj8ukerm8MEQavSiDTEtBsk= github.com/raulk/go-watchdog v1.3.0/go.mod h1:fIvOnLbF0b0ZwkB9YU4mOW9Did//4vPZtDqv66NfsMU= diff --git a/go.mod b/go.mod index aae886177c2..762a3add547 100644 --- a/go.mod +++ b/go.mod @@ -67,7 +67,7 @@ require ( github.com/jbenet/go-temp-err-catcher v0.1.0 github.com/jbenet/goprocess v0.1.4 github.com/libp2p/go-doh-resolver v0.4.0 - github.com/libp2p/go-libp2p v0.26.0 + github.com/libp2p/go-libp2p v0.26.1 github.com/libp2p/go-libp2p-http v0.4.0 github.com/libp2p/go-libp2p-kad-dht v0.21.1 github.com/libp2p/go-libp2p-kbucket v0.5.0 @@ -172,7 +172,7 @@ require ( github.com/libp2p/go-buffer-pool v0.1.0 // indirect github.com/libp2p/go-cidranger v1.1.0 // indirect github.com/libp2p/go-flow-metrics v0.1.0 // indirect - github.com/libp2p/go-libp2p-asn-util v0.2.0 // indirect + github.com/libp2p/go-libp2p-asn-util v0.3.0 // indirect github.com/libp2p/go-libp2p-gostream v0.5.0 // indirect github.com/libp2p/go-libp2p-xor v0.1.0 // indirect github.com/libp2p/go-mplex v0.7.0 // indirect @@ -210,7 +210,7 @@ require ( github.com/quic-go/qtls-go1-19 v0.2.1 // indirect github.com/quic-go/qtls-go1-20 v0.1.1 // indirect github.com/quic-go/quic-go v0.33.0 // indirect - github.com/quic-go/webtransport-go v0.5.1 // indirect + github.com/quic-go/webtransport-go v0.5.2 // indirect github.com/raulk/go-watchdog v1.3.0 // indirect github.com/rs/cors v1.7.0 // indirect github.com/samber/lo v1.36.0 // indirect diff --git a/go.sum b/go.sum index 93c9b97a4c1..13c15ccc89e 100644 --- a/go.sum +++ b/go.sum @@ -760,10 +760,10 @@ github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xS github.com/libp2p/go-libp2p v0.7.4/go.mod h1:oXsBlTLF1q7pxr+9w6lqzS1ILpyHsaBPniVO7zIHGMw= github.com/libp2p/go-libp2p v0.8.1/go.mod h1:QRNH9pwdbEBpx5DTJYg+qxcVaDMAz3Ee/qDKwXujH5o= github.com/libp2p/go-libp2p v0.14.3/go.mod h1:d12V4PdKbpL0T1/gsUNN8DfgMuRPDX8bS2QxCZlwRH0= -github.com/libp2p/go-libp2p v0.26.0 h1:0FE0bP9/G9YADjruqoFvf1snBBFvrdh1MmTuEeUkl2E= -github.com/libp2p/go-libp2p v0.26.0/go.mod h1:R8N+XhwPDPLNb4TKboKJKnDeg9vPw8+zlC6g793dTGw= -github.com/libp2p/go-libp2p-asn-util v0.2.0 h1:rg3+Os8jbnO5DxkC7K/Utdi+DkY3q/d1/1q+8WeNAsw= -github.com/libp2p/go-libp2p-asn-util v0.2.0/go.mod h1:WoaWxbHKBymSN41hWSq/lGKJEca7TNm58+gGJi2WsLI= +github.com/libp2p/go-libp2p v0.26.1 h1:I9bHj5KteIB1tsBWLT25TTttx5xSjun3ph/q/8Xax/k= +github.com/libp2p/go-libp2p v0.26.1/go.mod h1:HKQUKIQ5NhzabNMWq9Wczcs5Ksdx4LQ/ISAq4MRqBHQ= +github.com/libp2p/go-libp2p-asn-util v0.3.0 h1:gMDcMyYiZKkocGXDQ5nsUQyquC9+H+iLEQHwOCZ7s8s= +github.com/libp2p/go-libp2p-asn-util v0.3.0/go.mod h1:B1mcOrKUE35Xq/ASTmQ4tN3LNzVVaMNmq2NACuqyB9w= github.com/libp2p/go-libp2p-autonat v0.1.0/go.mod h1:1tLf2yXxiE/oKGtDwPYWTSYG3PtvYlJmg7NeVtPRqH8= github.com/libp2p/go-libp2p-autonat v0.1.1/go.mod h1:OXqkeGOY2xJVWKAGV2inNF5aKN/djNA3fdpCWloIudE= github.com/libp2p/go-libp2p-autonat v0.2.0/go.mod h1:DX+9teU4pEEoZUqR1PiMlqliONQdNbfzE1C718tcViI= @@ -1227,8 +1227,8 @@ github.com/quic-go/qtls-go1-20 v0.1.1 h1:KbChDlg82d3IHqaj2bn6GfKRj84Per2VGf5XV3w github.com/quic-go/qtls-go1-20 v0.1.1/go.mod h1:JKtK6mjbAVcUTN/9jZpvLbGxvdWIKS8uT7EiStoU1SM= github.com/quic-go/quic-go v0.33.0 h1:ItNoTDN/Fm/zBlq769lLJc8ECe9gYaW40veHCCco7y0= github.com/quic-go/quic-go v0.33.0/go.mod h1:YMuhaAV9/jIu0XclDXwZPAsP/2Kgr5yMYhe9oxhhOFA= -github.com/quic-go/webtransport-go v0.5.1 h1:1eVb7WDWCRoaeTtFHpFBJ6WDN1bSrPrRoW6tZgSw0Ow= -github.com/quic-go/webtransport-go v0.5.1/go.mod h1:OhmmgJIzTTqXK5xvtuX0oBpLV2GkLWNDA+UeTGJXErU= +github.com/quic-go/webtransport-go v0.5.2 h1:GA6Bl6oZY+g/flt00Pnu0XtivSD8vukOu3lYhJjnGEk= +github.com/quic-go/webtransport-go v0.5.2/go.mod h1:OhmmgJIzTTqXK5xvtuX0oBpLV2GkLWNDA+UeTGJXErU= github.com/rabbitmq/amqp091-go v1.1.0/go.mod h1:ogQDLSOACsLPsIq0NpbtiifNZi2YOz0VTJ0kHRghqbM= github.com/raulk/go-watchdog v1.3.0 h1:oUmdlHxdkXRJlwfG0O9omj8ukerm8MEQavSiDTEtBsk= github.com/raulk/go-watchdog v1.3.0/go.mod h1:fIvOnLbF0b0ZwkB9YU4mOW9Did//4vPZtDqv66NfsMU= From 145795b14815cc2a0b6f1599ca734966b3bcebf6 Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Mon, 27 Feb 2023 17:42:15 -0500 Subject: [PATCH 23/93] test: port rcmgr sharness tests to Go --- test/cli/harness/node.go | 13 + test/cli/harness/run.go | 4 + test/cli/rcmgr_test.go | 377 +++++++++++++++++++++++++++++ test/sharness/t0139-swarm-rcmgr.sh | 284 ---------------------- 4 files changed, 394 insertions(+), 284 deletions(-) create mode 100644 test/cli/rcmgr_test.go delete mode 100755 test/sharness/t0139-swarm-rcmgr.sh diff --git a/test/cli/harness/node.go b/test/cli/harness/node.go index 26a66ddd9fd..e486771cad9 100644 --- a/test/cli/harness/node.go +++ b/test/cli/harness/node.go @@ -1,6 +1,7 @@ package harness import ( + "bytes" "encoding/json" "errors" "fmt" @@ -62,6 +63,18 @@ func BuildNode(ipfsBin, baseDir string, id int) *Node { } } +func (n *Node) WriteBytes(filename string, b []byte) { + f, err := os.Create(filepath.Join(n.Dir, filename)) + if err != nil { + panic(err) + } + defer f.Close() + _, err = io.Copy(f, bytes.NewReader(b)) + if err != nil { + panic(err) + } +} + func (n *Node) ReadConfig() *config.Config { cfg, err := serial.Load(filepath.Join(n.Dir, "config")) if err != nil { diff --git a/test/cli/harness/run.go b/test/cli/harness/run.go index 1a6b32fc2f1..9cbb871bc10 100644 --- a/test/cli/harness/run.go +++ b/test/cli/harness/run.go @@ -38,6 +38,10 @@ type RunResult struct { Cmd *exec.Cmd } +func (r *RunResult) ExitCode() int { + return r.Cmd.ProcessState.ExitCode() +} + func environToMap(environ []string) map[string]string { m := map[string]string{} for _, e := range environ { diff --git a/test/cli/rcmgr_test.go b/test/cli/rcmgr_test.go new file mode 100644 index 00000000000..23e123655f7 --- /dev/null +++ b/test/cli/rcmgr_test.go @@ -0,0 +1,377 @@ +package cli + +import ( + "encoding/json" + "testing" + + "github.com/ipfs/kubo/config" + "github.com/ipfs/kubo/core/node/libp2p" + "github.com/ipfs/kubo/test/cli/harness" + rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestRcmgr(t *testing.T) { + t.Parallel() + + t.Run("Resource manager disabled", func(t *testing.T) { + t.Parallel() + node := harness.NewT(t).NewNode().Init() + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ResourceMgr.Enabled = config.False + }) + + node.StartDaemon() + + t.Run("swarm limit should fail", func(t *testing.T) { + res := node.RunIPFS("swarm", "limit", "system") + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.Lines()[0], "missing ResourceMgr") + }) + t.Run("swarm stats should fail", func(t *testing.T) { + res := node.RunIPFS("swarm", "stats", "all") + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.Lines()[0], "missing ResourceMgr") + }) + }) + + t.Run("Node in offline mode", func(t *testing.T) { + t.Parallel() + node := harness.NewT(t).NewNode().Init() + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ResourceMgr.Enabled = config.False + }) + node.StartDaemon() + + t.Run("swarm limit should fail", func(t *testing.T) { + res := node.RunIPFS("swarm", "limit", "system") + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.Lines()[0], "missing ResourceMgr") + }) + t.Run("swarm stats should fail", func(t *testing.T) { + res := node.RunIPFS("swarm", "stats", "all") + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.Lines()[0], "missing ResourceMgr") + }) + }) + + t.Run("Very high connmgr highwater", func(t *testing.T) { + node := harness.NewT(t).NewNode().Init() + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(1000) + }) + node.StartDaemon() + + res := node.RunIPFS("swarm", "limit", "system", "--enc=json") + require.Equal(t, 0, res.ExitCode()) + limits := unmarshalLimits(t, res.Stdout.Bytes()) + + assert.GreaterOrEqual(t, limits.ConnsInbound, 2000) + assert.GreaterOrEqual(t, limits.StreamsInbound, 2000) + }) + + t.Run("default configuration", func(t *testing.T) { + t.Parallel() + node := harness.NewT(t).NewNode().Init() + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(1000) + }) + node.StartDaemon() + + t.Run("conns and streams are above 800 for default connmgr settings", func(t *testing.T) { + res := node.RunIPFS("swarm", "limit", "system", "--enc=json") + require.Equal(t, 0, res.ExitCode()) + limits := unmarshalLimits(t, res.Stdout.Bytes()) + + assert.GreaterOrEqual(t, limits.ConnsInbound, 800) + assert.GreaterOrEqual(t, limits.StreamsInbound, 800) + }) + + t.Run("limits|stats should succeed", func(t *testing.T) { + res := node.RunIPFS("swarm", "limit", "all") + assert.Equal(t, 0, res.ExitCode()) + + limits := map[string]rcmgr.ResourceLimits{} + err := json.Unmarshal(res.Stdout.Bytes(), &limits) + require.NoError(t, err) + + assert.Greater(t, limits["System"].Memory, int64(0)) + assert.Greater(t, limits["System"].FD, 0) + assert.Greater(t, limits["System"].Conns, 0) + assert.Greater(t, limits["System"].ConnsInbound, 0) + assert.Greater(t, limits["System"].ConnsOutbound, 0) + assert.Greater(t, limits["System"].Streams, 0) + assert.Greater(t, limits["System"].StreamsInbound, 0) + assert.Greater(t, limits["System"].StreamsOutbound, 0) + assert.Greater(t, limits["Transient"].Memory, int64(0)) + }) + + t.Run("resetting limits should produce the same default limits", func(t *testing.T) { + resetRes := node.RunIPFS("swarm", "limit", "system", "--reset", "--enc=json") + require.Equal(t, 0, resetRes.ExitCode()) + limitRes := node.RunIPFS("swarm", "limit", "system", "--enc=json") + require.Equal(t, 0, limitRes.ExitCode()) + + assert.Equal(t, resetRes.Stdout.Bytes(), limitRes.Stdout.Bytes()) + }) + + t.Run("swarm stats system with filter should fail", func(t *testing.T) { + res := node.RunIPFS("swarm", "stats", "system", "--min-used-limit-perc=99") + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.Lines()[0], `Error: "min-used-limit-perc" can only be used when scope is "all"`) + }) + + t.Run("swarm limit reset on map values should work", func(t *testing.T) { + resetRes := node.RunIPFS("swarm", "limit", "peer:12D3KooWL7i1T9VSPeF8AgQApbyM51GNKZsYPvNvL347aMDmvNzG", "--reset", "--enc=json") + require.Equal(t, 0, resetRes.ExitCode()) + limitRes := node.RunIPFS("swarm", "limit", "peer:12D3KooWL7i1T9VSPeF8AgQApbyM51GNKZsYPvNvL347aMDmvNzG", "--enc=json") + require.Equal(t, 0, limitRes.ExitCode()) + + assert.Equal(t, resetRes.Stdout.Bytes(), limitRes.Stdout.Bytes()) + }) + + t.Run("scope is required using reset flags", func(t *testing.T) { + res := node.RunIPFS("swarm", "limit", "--reset") + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.Lines()[0], `Error: argument "scope" is required`) + }) + + t.Run("swarm stats works", func(t *testing.T) { + res := node.RunIPFS("swarm", "stats", "all", "--enc=json") + require.Equal(t, 0, res.ExitCode()) + + stats := libp2p.NetStatOut{} + err := json.Unmarshal(res.Stdout.Bytes(), &stats) + require.NoError(t, err) + + // every scope has the same fields, so we only inspect system + assert.Equal(t, rcmgr.LimitVal64(0), stats.System.Memory) + assert.Equal(t, rcmgr.LimitVal(0), stats.System.FD) + assert.Equal(t, rcmgr.LimitVal(0), stats.System.Conns) + assert.Equal(t, rcmgr.LimitVal(0), stats.System.ConnsInbound) + assert.Equal(t, rcmgr.LimitVal(0), stats.System.ConnsOutbound) + assert.Equal(t, rcmgr.LimitVal(0), stats.System.Streams) + assert.Equal(t, rcmgr.LimitVal(0), stats.System.StreamsInbound) + assert.Equal(t, rcmgr.LimitVal(0), stats.System.StreamsOutbound) + assert.Equal(t, rcmgr.LimitVal64(0), stats.Transient.Memory) + }) + }) + + t.Run("set system conns limit while daemon is not running", func(t *testing.T) { + node := harness.NewT(t).NewNode().Init() + res := node.RunIPFS("config", "--json", "Swarm.ResourceMgr.Limits.System.Conns", "99999") + require.Equal(t, 0, res.ExitCode()) + + t.Run("set an invalid limit which should result in a failure", func(t *testing.T) { + res := node.RunIPFS("config", "--json", "Swarm.ResourceMgr.Limits.System.Conns", "asdf") + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "failed to unmarshal") + }) + + node.StartDaemon() + + t.Run("new system conns limit is applied", func(t *testing.T) { + res := node.RunIPFS("swarm", "limit", "system", "--enc=json") + limits := unmarshalLimits(t, res.Stdout.Bytes()) + assert.Equal(t, limits.Conns, rcmgr.LimitVal(99999)) + }) + }) + + t.Run("set the system memory limit while the daemon is running", func(t *testing.T) { + node := harness.NewT(t).NewNode().Init().StartDaemon() + updateLimitsWithFile(t, node, "system", func(limits *rcmgr.ResourceLimits) { + limits.Memory = 99998 + }) + + assert.Equal(t, rcmgr.LimitVal64(99998), node.ReadConfig().Swarm.ResourceMgr.Limits.System.Memory) + + res := node.RunIPFS("swarm", "limit", "system", "--enc=json") + limits := unmarshalLimits(t, res.Stdout.Bytes()) + assert.Equal(t, rcmgr.LimitVal64(99998), limits.Memory) + }) + + t.Run("smoke test transient scope", func(t *testing.T) { + node := harness.NewT(t).NewNode().Init().StartDaemon() + updateLimitsWithFile(t, node, "transient", func(limits *rcmgr.ResourceLimits) { + limits.Memory = 88888 + }) + + res := node.RunIPFS("swarm", "limit", "transient", "--enc=json") + limits := unmarshalLimits(t, res.Stdout.Bytes()) + assert.Equal(t, rcmgr.LimitVal64(88888), limits.Memory) + }) + + t.Run("smoke test service scope", func(t *testing.T) { + node := harness.NewT(t).NewNode().Init().StartDaemon() + updateLimitsWithFile(t, node, "svc:foo", func(limits *rcmgr.ResourceLimits) { + limits.Memory = 77777 + }) + + res := node.RunIPFS("swarm", "limit", "svc:foo", "--enc=json") + limits := unmarshalLimits(t, res.Stdout.Bytes()) + assert.Equal(t, rcmgr.LimitVal64(77777), limits.Memory) + }) + + t.Run("smoke test protocol scope", func(t *testing.T) { + node := harness.NewT(t).NewNode().Init().StartDaemon() + updateLimitsWithFile(t, node, "proto:foo", func(limits *rcmgr.ResourceLimits) { + limits.Memory = 66666 + }) + + res := node.RunIPFS("swarm", "limit", "proto:foo", "--enc=json") + limits := unmarshalLimits(t, res.Stdout.Bytes()) + assert.Equal(t, rcmgr.LimitVal64(66666), limits.Memory) + }) + + t.Run("smoke test peer scope", func(t *testing.T) { + validPeerID := "QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN" + node := harness.NewT(t).NewNode().Init().StartDaemon() + updateLimitsWithFile(t, node, "peer:"+validPeerID, func(limits *rcmgr.ResourceLimits) { + limits.Memory = 66666 + }) + + res := node.RunIPFS("swarm", "limit", "peer:"+validPeerID, "--enc=json") + limits := unmarshalLimits(t, res.Stdout.Bytes()) + assert.Equal(t, rcmgr.LimitVal64(66666), limits.Memory) + + t.Parallel() + + t.Run("getting limit for invalid peer ID fails", func(t *testing.T) { + res := node.RunIPFS("swarm", "limit", "peer:foo") + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "invalid peer ID") + }) + + t.Run("setting limit for invalid peer ID fails", func(t *testing.T) { + filename := "invalid-peer-id.json" + node.WriteBytes(filename, []byte(`{"Memory":"99"}`)) + res := node.RunIPFS("swarm", "limit", "peer:foo", filename) + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "invalid peer ID") + }) + }) + + t.Run("", func(t *testing.T) { + nodes := harness.NewT(t).NewNodes(3).Init() + node0, node1, node2 := nodes[0], nodes[1], nodes[2] + // peerID0, peerID1, peerID2 := node0.PeerID(), node1.PeerID(), node2.PeerID() + peerID1, peerID2 := node1.PeerID().String(), node2.PeerID().String() + + node0.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ResourceMgr.Enabled = config.True + cfg.Swarm.ResourceMgr.Allowlist = []string{"/ip4/0.0.0.0/ipcidr/0/p2p/" + peerID2} + }) + + nodes.StartDaemons() + + // change system limits on node 0 + updateLimitsWithFile(t, node0, "system", func(limits *rcmgr.ResourceLimits) { + limits.Conns = rcmgr.BlockAllLimit + limits.ConnsInbound = rcmgr.BlockAllLimit + limits.ConnsOutbound = rcmgr.BlockAllLimit + }) + + t.Parallel() + t.Run("node 0 should fail to connect to node 1", func(t *testing.T) { + res := node0.Runner.Run(harness.RunRequest{ + Path: node0.IPFSBin, + Args: []string{"swarm", "connect", node1.SwarmAddrs()[0].String()}, + }) + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "failed to find any peer in table") + }) + + t.Run("node 0 should connect to node 2 since it is allowlisted", func(t *testing.T) { + res := node0.Runner.Run(harness.RunRequest{ + Path: node0.IPFSBin, + Args: []string{"swarm", "connect", node2.SwarmAddrs()[0].String()}, + }) + assert.Equal(t, 0, res.ExitCode()) + }) + + t.Run("node 0 should fail to ping node 1", func(t *testing.T) { + res := node0.RunIPFS("ping", "-n2", peerID1) + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "Error: ping failed") + }) + + t.Run("node 0 should be able to ping node 2", func(t *testing.T) { + res := node0.RunIPFS("ping", "-n2", peerID2) + assert.Equal(t, 0, res.ExitCode()) + }) + }) + + t.Run("daemon should refuse to start if connmgr.highwater < resources inbound", func(t *testing.T) { + t.Parallel() + t.Run("system conns", func(t *testing.T) { + node := harness.NewT(t).NewNode().Init() + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ResourceMgr.Limits = &rcmgr.PartialLimitConfig{} + cfg.Swarm.ResourceMgr.Limits.System.Conns = 128 + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) + cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) + }) + + res := node.RunIPFS("daemon") + assert.Equal(t, 1, res.ExitCode()) + }) + t.Run("system conns inbound", func(t *testing.T) { + node := harness.NewT(t).NewNode().Init() + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ResourceMgr.Limits = &rcmgr.PartialLimitConfig{} + cfg.Swarm.ResourceMgr.Limits.System.ConnsInbound = 128 + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) + cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) + }) + + res := node.RunIPFS("daemon") + assert.Equal(t, 1, res.ExitCode()) + }) + t.Run("system streams", func(t *testing.T) { + node := harness.NewT(t).NewNode().Init() + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ResourceMgr.Limits = &rcmgr.PartialLimitConfig{} + cfg.Swarm.ResourceMgr.Limits.System.Streams = 128 + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) + cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) + }) + + res := node.RunIPFS("daemon") + assert.Equal(t, 1, res.ExitCode()) + }) + t.Run("system streams inbound", func(t *testing.T) { + node := harness.NewT(t).NewNode().Init() + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ResourceMgr.Limits = &rcmgr.PartialLimitConfig{} + cfg.Swarm.ResourceMgr.Limits.System.StreamsInbound = 128 + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) + cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) + }) + + res := node.RunIPFS("daemon") + assert.Equal(t, 1, res.ExitCode()) + }) + }) +} + +func updateLimitsWithFile(t *testing.T, node *harness.Node, limit string, f func(*rcmgr.ResourceLimits)) { + filename := limit + ".json" + res := node.RunIPFS("swarm", "limit", limit) + limits := unmarshalLimits(t, res.Stdout.Bytes()) + + f(limits) + + limitsOut, err := json.Marshal(limits) + require.NoError(t, err) + node.WriteBytes(filename, limitsOut) + res = node.RunIPFS("swarm", "limit", limit, filename) + assert.Equal(t, 0, res.ExitCode()) +} + +func unmarshalLimits(t *testing.T, b []byte) *rcmgr.ResourceLimits { + limits := &rcmgr.ResourceLimits{} + err := json.Unmarshal(b, limits) + require.NoError(t, err) + return limits +} diff --git a/test/sharness/t0139-swarm-rcmgr.sh b/test/sharness/t0139-swarm-rcmgr.sh deleted file mode 100755 index d450c090860..00000000000 --- a/test/sharness/t0139-swarm-rcmgr.sh +++ /dev/null @@ -1,284 +0,0 @@ -#!/usr/bin/env bash -# -test_description="Test ipfs swarm ResourceMgr config and commands" - -. lib/test-lib.sh - -test_init_ipfs - -test_expect_success 'Disable resource manager' ' - ipfs config --bool Swarm.ResourceMgr.Enabled false -' - -# test correct behavior when resource manager is disabled -test_launch_ipfs_daemon - -test_expect_success 'Swarm limit should fail since RM is disabled' ' - test_expect_code 1 ipfs swarm limit system 2> actual && - test_should_contain "missing ResourceMgr" actual -' - -test_expect_success 'Swarm stats should fail since RM is disabled' ' - test_expect_code 1 ipfs swarm stats all 2> actual && - test_should_contain "missing ResourceMgr" actual -' - -test_kill_ipfs_daemon - -test_expect_success 'Enable resource manager' ' - ipfs config --bool Swarm.ResourceMgr.Enabled true -' - -# swarm limit|stats should fail in offline mode - -test_expect_success 'disconnected: swarm limit requires running daemon' ' - test_expect_code 1 ipfs swarm limit system 2> actual && - test_should_contain "missing ResourceMgr" actual -' -test_expect_success 'disconnected: swarm stats requires running daemon' ' - test_expect_code 1 ipfs swarm stats all 2> actual && - test_should_contain "missing ResourceMgr" actual -' - -# test sanity scaling -test_expect_success 'set very high connmgr highwater' ' - ipfs config --json Swarm.ConnMgr.HighWater 1000 -' - -test_launch_ipfs_daemon - -test_expect_success 'conns and streams are above 2000' ' - ipfs swarm limit system --enc=json | tee json && - [ "$(jq -r .ConnsInbound < json)" -ge 2000 ] && - [ "$(jq -r .StreamsInbound < json)" -ge 2000 ] -' - -test_kill_ipfs_daemon - -test_expect_success 'set previous connmgr highwater' ' - ipfs config --json Swarm.ConnMgr.HighWater 96 -' - -test_launch_ipfs_daemon - -test_expect_success 'conns and streams are above 800' ' - ipfs swarm limit system --enc=json | tee json && - [ "$(jq -r .ConnsInbound < json)" -ge 800 ] && - [ "$(jq -r .StreamsInbound < json)" -ge 800 ] -' - -# swarm limit|stats should succeed in online mode by default -# because Resource Manager is opt-out - -# every scope has the same fields, so we only inspect System -test_expect_success 'ResourceMgr enabled: swarm limit' ' - ipfs swarm limit system --enc=json | tee json && - jq -e .Conns < json && - jq -e .ConnsInbound < json && - jq -e .ConnsOutbound < json && - jq -e .FD < json && - jq -e .Memory < json && - jq -e .Streams < json && - jq -e .StreamsInbound < json && - jq -e .StreamsOutbound < json -' -test_expect_success 'ResourceMgr enabled: swarm limit reset' ' - ipfs swarm limit system --reset --enc=json 2> reset && - ipfs swarm limit system --enc=json 2> actual && - test_cmp reset actual -' - -test_expect_success 'Swarm stats system with filter should fail' ' - test_expect_code 1 ipfs swarm stats system --min-used-limit-perc=99 2> actual && - test_should_contain "Error: \"min-used-limit-perc\" can only be used when scope is \"all\"" actual -' - -test_expect_success 'ResourceMgr enabled: swarm limit reset on map values' ' - ipfs swarm limit peer:12D3KooWL7i1T9VSPeF8AgQApbyM51GNKZsYPvNvL347aMDmvNzG --reset --enc=json 2> reset && - ipfs swarm limit peer:12D3KooWL7i1T9VSPeF8AgQApbyM51GNKZsYPvNvL347aMDmvNzG --enc=json 2> actual && - test_cmp reset actual -' - -test_expect_success 'ResourceMgr enabled: scope is required using reset flag' ' - test_expect_code 1 ipfs swarm limit --reset 2> actual && - test_should_contain "Error: argument \"scope\" is required" actual -' - -test_expect_success 'connected: swarm stats all working properly' ' - test_expect_code 0 ipfs swarm stats all -' - -# every scope has the same fields, so we only inspect System -test_expect_success 'ResourceMgr enabled: swarm stats' ' - ipfs swarm stats all --enc=json | tee json && - jq -e .System.Memory < json && - jq -e .System.FD < json && - jq -e .System.Conns < json && - jq -e .System.ConnsInbound < json && - jq -e .System.ConnsOutbound < json && - jq -e .System.Streams < json && - jq -e .System.StreamsInbound < json && - jq -e .System.StreamsOutbound < json && - jq -e .Transient.Memory < json -' - -# shut down the daemon, set a limit in the config, and verify that it's applied -test_kill_ipfs_daemon - -test_expect_success "Set system conns limit while daemon is not running" " - ipfs config --json Swarm.ResourceMgr.Limits.System.Conns 99999 -" - -test_expect_success "Set an invalid limit, which should result in a failure" " - test_expect_code 1 ipfs config --json Swarm.ResourceMgr.Limits.System.Conns 'asdf' 2> actual && - test_should_contain 'failed to unmarshal' actual -" - -test_launch_ipfs_daemon - -test_expect_success 'Ensure the new system conns limit is applied' ' - ipfs swarm limit system --enc=json | tee json && - jq -e ".Conns == 99999" < json -' - -test_expect_success 'Set system memory limit while the daemon is running' ' - ipfs swarm limit system | jq ".Memory = 99998" > system.json && - ipfs swarm limit system system.json -' - -test_expect_success 'The new system limits were written to the config' ' - jq -e ".Swarm.ResourceMgr.Limits.System.Memory == \"99998\"" < "$IPFS_PATH/config" -' - -test_expect_success 'The new system limits are in the swarm limit output' ' - ipfs swarm limit system --enc=json | jq -e ".Memory == \"99998\"" -' - -# now test all the other scopes -test_expect_success 'Set limit on transient scope' ' - ipfs swarm limit transient | jq ".Memory = 88888" > transient.json && - ipfs swarm limit transient transient.json && - jq -e ".Swarm.ResourceMgr.Limits.Transient.Memory == \"88888\"" < "$IPFS_PATH/config" && - ipfs swarm limit transient --enc=json | tee limits && - jq -e ".Memory == \"88888\"" < limits -' - -test_expect_success 'Set limit on service scope' ' - ipfs swarm limit svc:foo | jq ".Memory = 77777" > service-foo.json && - ipfs swarm limit svc:foo service-foo.json --enc=json && - jq -e ".Swarm.ResourceMgr.Limits.Service.foo.Memory == \"77777\"" < "$IPFS_PATH/config" && - ipfs swarm limit svc:foo --enc=json | tee limits && - jq -e ".Memory == \"77777\"" < limits -' - -test_expect_success 'Set limit on protocol scope' ' - ipfs swarm limit proto:foo | jq ".Memory = 66666" > proto-foo.json && - ipfs swarm limit proto:foo proto-foo.json --enc=json && - jq -e ".Swarm.ResourceMgr.Limits.Protocol.foo.Memory == \"66666\"" < "$IPFS_PATH/config" && - ipfs swarm limit proto:foo --enc=json | tee limits && - jq -e ".Memory == \"66666\"" < limits -' - -# any valid peer id -PEER_ID=QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN - -test_expect_success 'Set limit on peer scope' ' - ipfs swarm limit peer:$PEER_ID | jq ".Memory = 66666" > peer-$PEER_ID.json && - ipfs swarm limit peer:$PEER_ID peer-$PEER_ID.json --enc=json && - jq -e ".Swarm.ResourceMgr.Limits.Peer.${PEER_ID}.Memory == \"66666\"" < "$IPFS_PATH/config" && - ipfs swarm limit peer:$PEER_ID --enc=json | tee limits && - jq -e ".Memory == \"66666\"" < limits -' - -test_expect_success 'Get limit for peer scope with an invalid peer ID' ' - test_expect_code 1 ipfs swarm limit peer:foo 2> actual && - test_should_contain "invalid peer ID" actual -' - -test_expect_success 'Set limit for peer scope with an invalid peer ID' ' - echo "{\"Memory\": 99}" > invalid-peer-id.json && - test_expect_code 1 ipfs swarm limit peer:foo invalid-peer-id.json 2> actual && - test_should_contain "invalid peer ID" actual -' - -test_kill_ipfs_daemon - -## Test allowlist - -test_expect_success 'init iptb' ' - iptb testbed create -type localipfs -count 3 -init -' - -test_expect_success 'peer ids' ' - PEERID_0=$(iptb attr get 0 id) && - PEERID_1=$(iptb attr get 1 id) && - PEERID_2=$(iptb attr get 2 id) -' - -#enable resource manager -test_expect_success 'enable RCMGR' ' - ipfsi 0 config --bool Swarm.ResourceMgr.Enabled true && - ipfsi 0 config --json Swarm.ResourceMgr.Allowlist "[\"/ip4/0.0.0.0/ipcidr/0/p2p/$PEERID_2\"]" -' - -test_expect_success 'start nodes' ' - iptb start -wait [0-2] -' - -test_expect_success "change system limits on node 0" ' - ipfsi 0 swarm limit system | jq ". + {Conns: 0,ConnsInbound: 0, ConnsOutbound: 0}" > system.json && - ipfsi 0 swarm limit system system.json -' - -test_expect_success "node 0 fails to connect to 1" ' - test_expect_code 1 iptb connect 0 1 -' - -test_expect_success "node 0 connects to 2 because it's allowlisted" ' - iptb connect 0 2 -' - -test_expect_success "node 0 fails to ping 1" ' - test_expect_code 1 ipfsi 0 ping -n2 -- "$PEERID_1" 2> actual && - test_should_contain "Error: ping failed" actual -' - -test_expect_success "node 1 can ping 2" ' - ipfsi 0 ping -n2 -- "$PEERID_2" -' - -test_expect_success 'stop iptb' ' - iptb stop 0 && - iptb stop 1 && - iptb stop 2 -' - -## Test daemon refuse to start if connmgr.highwater < ressources inbound - -test_expect_success "node refuse to start if Swarm.ResourceMgr.Limits.System.Conns <= Swarm.ConnMgr.HighWater" ' - ipfs config --json Swarm.ResourceMgr.Limits.System.Conns 128 && - ipfs config --json Swarm.ConnMgr.HighWater 128 && - ipfs config --json Swarm.ConnMgr.LowWater 64 && - test_expect_code 1 ipfs daemon && - ipfs config --json Swarm.ResourceMgr.Limits.System.Conns 256 -' - -test_expect_success "node refuse to start if Swarm.ResourceMgr.Limits.System.ConnsInbound <= Swarm.ConnMgr.HighWater" ' - ipfs config --json Swarm.ResourceMgr.Limits.System.ConnsInbound 128 && - test_expect_code 1 ipfs daemon && - ipfs config --json Swarm.ResourceMgr.Limits.System.ConnsInbound 256 -' - -test_expect_success "node refuse to start if Swarm.ResourceMgr.Limits.System.Streams <= Swarm.ConnMgr.HighWater" ' - ipfs config --json Swarm.ResourceMgr.Limits.System.Streams 128 && - test_expect_code 1 ipfs daemon && - ipfs config --json Swarm.ResourceMgr.Limits.System.Streams 256 -' - -test_expect_success "node refuse to start if Swarm.ResourceMgr.Limits.System.StreamsInbound <= Swarm.ConnMgr.HighWater" ' - ipfs config --json Swarm.ResourceMgr.Limits.System.StreamsInbound 128 && - test_expect_code 1 ipfs daemon && - ipfs config --json Swarm.ResourceMgr.Limits.System.StreamsInbound 256 -' - -test_done From 68f4dd4427c46a2a08ccde73d5221c12387a541e Mon Sep 17 00:00:00 2001 From: Marten Seemann Date: Thu, 2 Mar 2023 13:14:54 +1300 Subject: [PATCH 24/93] chore: update go-libp2p to v0.26.2 --- docs/examples/kubo-as-a-library/go.mod | 2 +- docs/examples/kubo-as-a-library/go.sum | 4 ++-- go.mod | 4 ++-- go.sum | 8 ++++---- 4 files changed, 9 insertions(+), 9 deletions(-) diff --git a/docs/examples/kubo-as-a-library/go.mod b/docs/examples/kubo-as-a-library/go.mod index 77dc8403874..c3e8e16d1e8 100644 --- a/docs/examples/kubo-as-a-library/go.mod +++ b/docs/examples/kubo-as-a-library/go.mod @@ -10,7 +10,7 @@ require ( github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 github.com/ipfs/interface-go-ipfs-core v0.11.0 github.com/ipfs/kubo v0.0.0-00010101000000-000000000000 - github.com/libp2p/go-libp2p v0.26.1 + github.com/libp2p/go-libp2p v0.26.2 github.com/multiformats/go-multiaddr v0.8.0 ) diff --git a/docs/examples/kubo-as-a-library/go.sum b/docs/examples/kubo-as-a-library/go.sum index 6e365b6a7c8..a5b30e5d700 100644 --- a/docs/examples/kubo-as-a-library/go.sum +++ b/docs/examples/kubo-as-a-library/go.sum @@ -730,8 +730,8 @@ github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xS github.com/libp2p/go-libp2p v0.7.4/go.mod h1:oXsBlTLF1q7pxr+9w6lqzS1ILpyHsaBPniVO7zIHGMw= github.com/libp2p/go-libp2p v0.8.1/go.mod h1:QRNH9pwdbEBpx5DTJYg+qxcVaDMAz3Ee/qDKwXujH5o= github.com/libp2p/go-libp2p v0.14.3/go.mod h1:d12V4PdKbpL0T1/gsUNN8DfgMuRPDX8bS2QxCZlwRH0= -github.com/libp2p/go-libp2p v0.26.1 h1:I9bHj5KteIB1tsBWLT25TTttx5xSjun3ph/q/8Xax/k= -github.com/libp2p/go-libp2p v0.26.1/go.mod h1:HKQUKIQ5NhzabNMWq9Wczcs5Ksdx4LQ/ISAq4MRqBHQ= +github.com/libp2p/go-libp2p v0.26.2 h1:eHEoW/696FP7/6DxOvcrKfTD6Bi0DExxiMSZUJxswA0= +github.com/libp2p/go-libp2p v0.26.2/go.mod h1:x75BN32YbwuY0Awm2Uix4d4KOz+/4piInkp4Wr3yOo8= github.com/libp2p/go-libp2p-asn-util v0.3.0 h1:gMDcMyYiZKkocGXDQ5nsUQyquC9+H+iLEQHwOCZ7s8s= github.com/libp2p/go-libp2p-asn-util v0.3.0/go.mod h1:B1mcOrKUE35Xq/ASTmQ4tN3LNzVVaMNmq2NACuqyB9w= github.com/libp2p/go-libp2p-autonat v0.1.0/go.mod h1:1tLf2yXxiE/oKGtDwPYWTSYG3PtvYlJmg7NeVtPRqH8= diff --git a/go.mod b/go.mod index 762a3add547..ec0e3e8a5ed 100644 --- a/go.mod +++ b/go.mod @@ -67,7 +67,7 @@ require ( github.com/jbenet/go-temp-err-catcher v0.1.0 github.com/jbenet/goprocess v0.1.4 github.com/libp2p/go-doh-resolver v0.4.0 - github.com/libp2p/go-libp2p v0.26.1 + github.com/libp2p/go-libp2p v0.26.2 github.com/libp2p/go-libp2p-http v0.4.0 github.com/libp2p/go-libp2p-kad-dht v0.21.1 github.com/libp2p/go-libp2p-kbucket v0.5.0 @@ -172,7 +172,7 @@ require ( github.com/libp2p/go-buffer-pool v0.1.0 // indirect github.com/libp2p/go-cidranger v1.1.0 // indirect github.com/libp2p/go-flow-metrics v0.1.0 // indirect - github.com/libp2p/go-libp2p-asn-util v0.3.0 // indirect + github.com/libp2p/go-libp2p-asn-util v0.2.0 // indirect github.com/libp2p/go-libp2p-gostream v0.5.0 // indirect github.com/libp2p/go-libp2p-xor v0.1.0 // indirect github.com/libp2p/go-mplex v0.7.0 // indirect diff --git a/go.sum b/go.sum index 13c15ccc89e..9f666f40511 100644 --- a/go.sum +++ b/go.sum @@ -760,10 +760,10 @@ github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xS github.com/libp2p/go-libp2p v0.7.4/go.mod h1:oXsBlTLF1q7pxr+9w6lqzS1ILpyHsaBPniVO7zIHGMw= github.com/libp2p/go-libp2p v0.8.1/go.mod h1:QRNH9pwdbEBpx5DTJYg+qxcVaDMAz3Ee/qDKwXujH5o= github.com/libp2p/go-libp2p v0.14.3/go.mod h1:d12V4PdKbpL0T1/gsUNN8DfgMuRPDX8bS2QxCZlwRH0= -github.com/libp2p/go-libp2p v0.26.1 h1:I9bHj5KteIB1tsBWLT25TTttx5xSjun3ph/q/8Xax/k= -github.com/libp2p/go-libp2p v0.26.1/go.mod h1:HKQUKIQ5NhzabNMWq9Wczcs5Ksdx4LQ/ISAq4MRqBHQ= -github.com/libp2p/go-libp2p-asn-util v0.3.0 h1:gMDcMyYiZKkocGXDQ5nsUQyquC9+H+iLEQHwOCZ7s8s= -github.com/libp2p/go-libp2p-asn-util v0.3.0/go.mod h1:B1mcOrKUE35Xq/ASTmQ4tN3LNzVVaMNmq2NACuqyB9w= +github.com/libp2p/go-libp2p v0.26.2 h1:eHEoW/696FP7/6DxOvcrKfTD6Bi0DExxiMSZUJxswA0= +github.com/libp2p/go-libp2p v0.26.2/go.mod h1:x75BN32YbwuY0Awm2Uix4d4KOz+/4piInkp4Wr3yOo8= +github.com/libp2p/go-libp2p-asn-util v0.2.0 h1:rg3+Os8jbnO5DxkC7K/Utdi+DkY3q/d1/1q+8WeNAsw= +github.com/libp2p/go-libp2p-asn-util v0.2.0/go.mod h1:WoaWxbHKBymSN41hWSq/lGKJEca7TNm58+gGJi2WsLI= github.com/libp2p/go-libp2p-autonat v0.1.0/go.mod h1:1tLf2yXxiE/oKGtDwPYWTSYG3PtvYlJmg7NeVtPRqH8= github.com/libp2p/go-libp2p-autonat v0.1.1/go.mod h1:OXqkeGOY2xJVWKAGV2inNF5aKN/djNA3fdpCWloIudE= github.com/libp2p/go-libp2p-autonat v0.2.0/go.mod h1:DX+9teU4pEEoZUqR1PiMlqliONQdNbfzE1C718tcViI= From 74cfddc39e29671cc57fb2db6b8539fc3b1860c5 Mon Sep 17 00:00:00 2001 From: galargh Date: Thu, 2 Mar 2023 10:34:38 +0100 Subject: [PATCH 25/93] ci: remove disabled testground workflow --- .github/workflows/testground-on-push.yml | 38 ------------------------ 1 file changed, 38 deletions(-) delete mode 100644 .github/workflows/testground-on-push.yml diff --git a/.github/workflows/testground-on-push.yml b/.github/workflows/testground-on-push.yml deleted file mode 100644 index 7b55dbdee3b..00000000000 --- a/.github/workflows/testground-on-push.yml +++ /dev/null @@ -1,38 +0,0 @@ ---- -name: Testground PR Checker - -on: - workflow_dispatch: - push: - - -jobs: - testground: - if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' - runs-on: ubuntu-latest - name: ${{ matrix.composition_file }} - strategy: - matrix: - include: - - backend_addr: ci.testground.ipfs.team - backend_proto: https - plan_directory: testplans/bitswap - composition_file: testplans/bitswap/_compositions/small-k8s.toml - - backend_addr: ci.testground.ipfs.team - backend_proto: https - plan_directory: testplans/bitswap - composition_file: testplans/bitswap/_compositions/medium-k8s.toml - - backend_addr: ci.testground.ipfs.team - backend_proto: https - plan_directory: testplans/bitswap - composition_file: testplans/bitswap/_compositions/large-k8s.toml - steps: - - uses: actions/checkout@v2 - - name: testground run - uses: testground/testground-github-action@v1 - timeout-minutes: 5 - with: - backend_addr: ${{ matrix.backend_addr }} - backend_proto: ${{ matrix.backend_proto }} - plan_directory: ${{ matrix.plan_directory }} - composition_file: ${{ matrix.composition_file }} From e1f38d7567df725d37024e7f294ec00d584c84ef Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Thu, 2 Mar 2023 10:51:57 +0100 Subject: [PATCH 26/93] ci: set sensible timeouts on all gha jobs (#9683) --- .github/workflows/build.yml | 5 +++++ .github/workflows/codeql-analysis.yml | 1 + .github/workflows/docker-build.yml | 1 + .github/workflows/docker-image.yml | 1 + .github/workflows/gobuild.yml | 1 + .github/workflows/golang-analysis.yml | 1 + .github/workflows/golint.yml | 1 + .github/workflows/gotest.yml | 1 + .github/workflows/runner.yml | 1 + .github/workflows/sharness.yml | 1 + .github/workflows/sync-release-assets.yml | 1 + 11 files changed, 15 insertions(+) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 5e350cad77a..4e91b244b65 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -14,6 +14,7 @@ jobs: prepare: if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' runs-on: ubuntu-latest + timeout-minutes: 5 env: TEST_NO_DOCKER: 1 TEST_NO_FUSE: 1 @@ -40,6 +41,7 @@ jobs: ipfs-interop: needs: [prepare] runs-on: ubuntu-latest + timeout-minutes: 20 strategy: matrix: suites: @@ -83,6 +85,7 @@ jobs: go-ipfs-api: needs: [prepare] runs-on: ubuntu-latest + timeout-minutes: 5 env: TEST_NO_DOCKER: 1 TEST_NO_FUSE: 1 @@ -122,6 +125,7 @@ jobs: go-ipfs-http-client: needs: [prepare] runs-on: ubuntu-latest + timeout-minutes: 5 env: TEST_NO_DOCKER: 1 TEST_NO_FUSE: 1 @@ -154,6 +158,7 @@ jobs: ipfs-webui: needs: [prepare] runs-on: ubuntu-latest + timeout-minutes: 20 env: NO_SANDBOX: true LIBP2P_TCP_REUSEPORT: false diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml index e12af6b4e41..c5c355fac38 100644 --- a/.github/workflows/codeql-analysis.yml +++ b/.github/workflows/codeql-analysis.yml @@ -16,6 +16,7 @@ jobs: if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' name: Analyze runs-on: ubuntu-latest + timeout-minutes: 20 strategy: fail-fast: false diff --git a/.github/workflows/docker-build.yml b/.github/workflows/docker-build.yml index 86c50bec7f1..23e29bf39e2 100644 --- a/.github/workflows/docker-build.yml +++ b/.github/workflows/docker-build.yml @@ -11,6 +11,7 @@ jobs: docker-build: if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' runs-on: ubuntu-latest + timeout-minutes: 10 env: IMAGE_NAME: ipfs/kubo WIP_IMAGE_TAG: wip diff --git a/.github/workflows/docker-image.yml b/.github/workflows/docker-image.yml index a7416e388f4..f798bb2022e 100644 --- a/.github/workflows/docker-image.yml +++ b/.github/workflows/docker-image.yml @@ -14,6 +14,7 @@ jobs: if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' name: Push Docker image to Docker Hub runs-on: ubuntu-latest + timeout-minutes: 90 env: IMAGE_NAME: ipfs/kubo LEGACY_IMAGE_NAME: ipfs/go-ipfs diff --git a/.github/workflows/gobuild.yml b/.github/workflows/gobuild.yml index 120e9469302..532d34590ce 100644 --- a/.github/workflows/gobuild.yml +++ b/.github/workflows/gobuild.yml @@ -14,6 +14,7 @@ jobs: gobuild: needs: [runner] runs-on: ${{ fromJSON(needs.runner.outputs.config).labels }} + timeout-minutes: 20 env: TEST_NO_DOCKER: 1 TEST_VERBOSE: 1 diff --git a/.github/workflows/golang-analysis.yml b/.github/workflows/golang-analysis.yml index 958ece6686d..1bc66900349 100644 --- a/.github/workflows/golang-analysis.yml +++ b/.github/workflows/golang-analysis.yml @@ -11,6 +11,7 @@ jobs: unit: if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' runs-on: ubuntu-latest + timeout-minutes: 10 name: All steps: - uses: actions/checkout@v2 diff --git a/.github/workflows/golint.yml b/.github/workflows/golint.yml index 9623ae4b608..a6593582da7 100644 --- a/.github/workflows/golint.yml +++ b/.github/workflows/golint.yml @@ -11,6 +11,7 @@ jobs: golint: if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' runs-on: ubuntu-latest + timeout-minutes: 10 env: TEST_NO_DOCKER: 1 TEST_NO_FUSE: 1 diff --git a/.github/workflows/gotest.yml b/.github/workflows/gotest.yml index 2c50fd3e534..8eb41a34dbd 100644 --- a/.github/workflows/gotest.yml +++ b/.github/workflows/gotest.yml @@ -11,6 +11,7 @@ jobs: gotest: if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' runs-on: ubuntu-latest + timeout-minutes: 20 env: TEST_NO_DOCKER: 1 TEST_NO_FUSE: 1 diff --git a/.github/workflows/runner.yml b/.github/workflows/runner.yml index afb4d740d3f..c8aef2256d0 100644 --- a/.github/workflows/runner.yml +++ b/.github/workflows/runner.yml @@ -10,6 +10,7 @@ on: jobs: choose: runs-on: ubuntu-latest + timeout-minutes: 1 outputs: config: ${{ steps.config.outputs.result }} steps: diff --git a/.github/workflows/sharness.yml b/.github/workflows/sharness.yml index 6241e3fe62b..44df1e8a051 100644 --- a/.github/workflows/sharness.yml +++ b/.github/workflows/sharness.yml @@ -14,6 +14,7 @@ jobs: sharness: needs: [runner] runs-on: ${{ fromJSON(needs.runner.outputs.config).labels }} + timeout-minutes: 20 defaults: run: shell: bash diff --git a/.github/workflows/sync-release-assets.yml b/.github/workflows/sync-release-assets.yml index da3ca9582b5..f2527d47c46 100644 --- a/.github/workflows/sync-release-assets.yml +++ b/.github/workflows/sync-release-assets.yml @@ -13,6 +13,7 @@ jobs: sync-github-and-dist-ipfs-tech: if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' runs-on: "ubuntu-latest" + timeout-minutes: 5 steps: - uses: ipfs/download-ipfs-distribution-action@v1 - uses: ipfs/start-ipfs-daemon-action@v1 From fe8f72e70739b7a55330a2a609fe3fd2a0bfc1ae Mon Sep 17 00:00:00 2001 From: galargh Date: Tue, 28 Feb 2023 13:00:23 +0100 Subject: [PATCH 27/93] ci: replace junit html generation with gh action --- .github/workflows/sharness.yml | 18 +++++++-- test/sharness/Rules.mk | 15 ------- test/sharness/lib/download-saxon.sh | 39 ------------------- test/sharness/lib/test-generate-junit-html.sh | 20 ---------- 4 files changed, 15 insertions(+), 77 deletions(-) delete mode 100755 test/sharness/lib/download-saxon.sh delete mode 100755 test/sharness/lib/test-generate-junit-html.sh diff --git a/.github/workflows/sharness.yml b/.github/workflows/sharness.yml index 44df1e8a051..8809f2a5308 100644 --- a/.github/workflows/sharness.yml +++ b/.github/workflows/sharness.yml @@ -56,9 +56,7 @@ jobs: make -O -j "$PARALLEL" \ test_sharness \ coverage/sharness_tests.coverprofile \ - test/sharness/test-results/sharness.xml \ - test/sharness/test-results/sharness.html \ - test/sharness/test-results/sharness-html + test/sharness/test-results/sharness.xml working-directory: kubo env: TEST_NO_DOCKER: 0 @@ -88,6 +86,13 @@ jobs: echo "# Summary" >> $GITHUB_STEP_SUMMARY echo >> $GITHUB_STEP_SUMMARY cat kubo/test/sharness/test-results/summary.txt >> $GITHUB_STEP_SUMMARY + - name: Generate one-page HTML report + uses: pl-strflt/junit-xml-to-html@v1 + if: failure() || success() + with: + mode: no-frames + input: kubo/test/sharness/test-results/sharness.xml + output: kubo/test/sharness/test-results/sharness.html - name: Upload one-page HTML report to S3 id: one-page uses: pl-strflt/tf-aws-gh-runner/.github/actions/upload-artifact@main @@ -101,6 +106,13 @@ jobs: with: name: sharness.html path: kubo/test/sharness/test-results/sharness.html + - name: Generate full HTML report + uses: pl-strflt/junit-xml-to-html@v1 + if: failure() || success() + with: + mode: frames + input: kubo/test/sharness/test-results/sharness.xml + output: kubo/test/sharness/test-results/sharness-html - name: Upload full HTML report to S3 id: full uses: pl-strflt/tf-aws-gh-runner/.github/actions/upload-artifact@main diff --git a/test/sharness/Rules.mk b/test/sharness/Rules.mk index 20b2634dbb6..f95aee15e0d 100644 --- a/test/sharness/Rules.mk +++ b/test/sharness/Rules.mk @@ -47,21 +47,6 @@ $(d)/test-results/sharness.xml: $(T_$(d)) @(cd $(@D)/.. && ./lib/test-aggregate-junit-reports.sh) .PHONY: $(d)/test-results/sharness.xml -$(d)/download-saxon: - @echo "*** $@ ***" - @(cd $(@D) && ./lib/download-saxon.sh) -.PHONY: $(d)/download-saxon - -$(d)/test-results/sharness-html: $(d)/test-results/sharness.xml $(d)/download-saxon - @echo "*** $@ ***" - @(cd $(@D)/.. && ./lib/test-generate-junit-html.sh frames) -.PHONY: $(d)/test-results/sharness-html - -$(d)/test-results/sharness.html: $(d)/test-results/sharness.xml $(d)/download-saxon - @echo "*** $@ ***" - @(cd $(@D)/.. && ./lib/test-generate-junit-html.sh no-frames) -.PHONY: $(d)/test-results/sharness.html - $(d)/clean-test-results: rm -rf $(@D)/test-results .PHONY: $(d)/clean-test-results diff --git a/test/sharness/lib/download-saxon.sh b/test/sharness/lib/download-saxon.sh deleted file mode 100755 index cc645238f12..00000000000 --- a/test/sharness/lib/download-saxon.sh +++ /dev/null @@ -1,39 +0,0 @@ -#!/bin/bash - -dependencies=( - "url=https://raw.githubusercontent.com/pl-strflt/Saxon-HE/3e039cdbccf4efb9643736f34c839a3bae3402ae/11/Java/SaxonHE11-4J.zip;md5=8a4783d307c32c898f8995b8f337fd6b" - "url=https://raw.githubusercontent.com/pl-strflt/ant/c781f7d79b92cc55530245d9554682a47f46851e/src/etc/junit-frames-saxon.xsl;md5=6eb013566903a91e4959413f6ff144d0" - "url=https://raw.githubusercontent.com/pl-strflt/ant/c781f7d79b92cc55530245d9554682a47f46851e/src/etc/junit-noframes-saxon.xsl;md5=8d54882d5f9d32a7743ec675cc2e30ac" -) - -dependenciesdir="lib/dependencies" -mkdir -p "$dependenciesdir" - -get_md5() { - md5sum "$1" | cut -d ' ' -f 1 -} - -for dependency in "${dependencies[@]}"; do - url="$(echo "$dependency" | cut -d ';' -f 1 | cut -d '=' -f 2)" - md5="$(echo "$dependency" | cut -d ';' -f 2 | cut -d '=' -f 2)" - filename="$(basename "$url")" - if test -f "$dependenciesdir/$filename" && test "$(get_md5 "$dependenciesdir/$filename")" = "$md5"; then - echo "Using cached $filename" - else - echo "Downloading $filename" - curl -L --max-redirs 5 --retry 5 --no-progress-meter --output "$dependenciesdir/$filename" "$url" - actual_md5="$(get_md5 "$dependenciesdir/$filename")" - if test "$actual_md5" != "$md5"; then - echo "Downloaded $filename has wrong md5sum ('$actual_md5' != '$md5')" - exit 1 - fi - dirname=${filename%.*} - extension=${filename#$dirname.} - if test "$extension" = "zip"; then - echo "Removing old $dependenciesdir/$dirname" - rm -rf "$dependenciesdir/$dirname" - echo "Unzipping $dependenciesdir/$filename" - unzip "$dependenciesdir/$filename" -d "$dependenciesdir/$dirname" - fi - fi -done diff --git a/test/sharness/lib/test-generate-junit-html.sh b/test/sharness/lib/test-generate-junit-html.sh deleted file mode 100755 index 2790a7b9d0c..00000000000 --- a/test/sharness/lib/test-generate-junit-html.sh +++ /dev/null @@ -1,20 +0,0 @@ -#!/bin/bash - -case "$1" in - "frames") - java -jar lib/dependencies/SaxonHE11-4J/saxon-he-11.4.jar \ - -s:test-results/sharness.xml \ - -xsl:lib/dependencies/junit-frames-saxon.xsl \ - output.dir=$(pwd)/test-results/sharness-html - ;; - "no-frames") - java -jar lib/dependencies/SaxonHE11-4J/saxon-he-11.4.jar \ - -s:test-results/sharness.xml \ - -xsl:lib/dependencies/junit-noframes-saxon.xsl \ - -o:test-results/sharness.html - ;; - *) - echo "Usage: $0 [frames|no-frames]" - exit 1 - ;; -esac From f84ad6d627fcd6d70f173229db22084837526ccf Mon Sep 17 00:00:00 2001 From: Steve Loeppky Date: Wed, 1 Mar 2023 15:12:38 -0800 Subject: [PATCH 28/93] Doc updates/additions --- docs/changelogs/v0.19.md | 13 ++- docs/config.md | 62 +-------------- docs/libp2p-resource-management.md | 123 ++++++++++++----------------- 3 files changed, 64 insertions(+), 134 deletions(-) diff --git a/docs/changelogs/v0.19.md b/docs/changelogs/v0.19.md index e1c28482d30..7663308a6db 100644 --- a/docs/changelogs/v0.19.md +++ b/docs/changelogs/v0.19.md @@ -1,11 +1,12 @@ + # Kubo changelog v0.19 -- [v0.19.0](#v0190) - + ## v0.19.0 - [Overview](#overview) - [🔦 Highlights](#-highlights) + - [Improving the libp2p resource management integration](#improving-the-libp2p-resource-management-integration) - [📝 Changelog](#-changelog) - [👨‍👩‍👧‍👦 Contributors](#-contributors) @@ -13,6 +14,14 @@ ### 🔦 Highlights +#### Improving the libp2p resource management integration +There are further followups up on libp2p resource manager improvements in Kubo [0.18.0](https://github.com/ipfs/kubo/blob/master/docs/changelogs/v0.18.md#improving-libp2p-resource-management-integration-1) +and [0.18.1](https://github.com/ipfs/kubo/blob/master/docs/changelogs/v0.18.md#improving-libp2p-resource-management-integration): +1. `ipfs swarm limits` and `ipfs swarm stats` have been replaced by `ipfs swarm resources` to provide a single/combined view for limits and their current usage in a more intuitive ordering. +1. Removal of `Swarm.ResourceMgr.Limits` config. Instead [the power user can specify limits in a .json file that are fed directly to go-libp2p](https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#user-supplied-override-limits). This allows the power user to take advantage of the [new resource manager types introduced in go-libp2p 0.25](https://github.com/libp2p/go-libp2p/blob/master/CHANGELOG.md#new-resource-manager-types-) including "use default", "unlimited", "block all". + - Note: we don't expect most users to need these capablities, but they are there if so. +1. [Doc updates](https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md). + ### 📝 Changelog ### 👨‍👩‍👧‍👦 Contributors diff --git a/docs/config.md b/docs/config.md index 76a49ba03e0..30a4e760134 100644 --- a/docs/config.md +++ b/docs/config.md @@ -146,7 +146,6 @@ config file at runtime. - [`Swarm.ResourceMgr.Enabled`](#swarmresourcemgrenabled) - [`Swarm.ResourceMgr.MaxMemory`](#swarmresourcemgrmaxmemory) - [`Swarm.ResourceMgr.MaxFileDescriptors`](#swarmresourcemgrmaxfiledescriptors) - - [`Swarm.ResourceMgr.Limits`](#swarmresourcemgrlimits) - [`Swarm.ResourceMgr.Allowlist`](#swarmresourcemgrallowlist) - [`Swarm.Transports`](#swarmtransports) - [`Swarm.Transports.Network`](#swarmtransportsnetwork) @@ -1846,6 +1845,8 @@ This value is also used to scale the limit on various resources at various scope when the default limits (discussed in [libp2p resource management](./libp2p-resource-management.md)) are used. For example, increasing this value will increase the default limit for incoming connections. +It is possible to inspect the runtime limits via `ipfs swarm resources --help`. + Default: `[TOTAL_SYSTEM_MEMORY]/2` Type: `optionalBytes` @@ -1859,65 +1860,6 @@ This param is ignored on Windows. Default `[TOTAL_SYSTEM_FILE_DESCRIPTORS]/2` Type: `optionalInteger` -#### `Swarm.ResourceMgr.Limits` - -Map of resource limits [per scope](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#resource-scopes). - -The map supports fields from the [`LimitConfig` struct](https://github.com/libp2p/go-libp2p/blob/master/p2p/host/resource-manager/limit_defaults.go#L111). - -[`BaseLimit`s](https://github.com/libp2p/go-libp2p/blob/master/p2p/host/resource-manager/limit.go#L89) can be set for any scope, and within the `BaseLimit`, all limit s are optional. - -The `Swarm.ResourceMgr.Limits` override the default limits described above. -Any override `BaseLimits` or limit s from `Swarm.ResourceMgr.Limits` -that aren't specified will use the [computed default limits](./libp2p-resource-management.md#computed-default-limits). - -Until [ipfs/kubo#9564](https://github.com/ipfs/kubo/issues/9564) is addressed, there isn't a way to set an override limit of zero. -0 is currently ignored. 0 currently means use to use the [computed default limits](./libp2p-resource-management.md#computed-default-limits). - -Example #1: setting limits for a specific scope -```json -{ - "Swarm": { - "ResourceMgr": { - "Limits": { - "System": { - "Memory": 1073741824, - "FD": 512, - "Conns": 1024, - "ConnsInbound": 256, - "ConnsOutbound": 1024, - "Streams": 16384, - "StreamsInbound": 4096, - "StreamsOutbound": 16384 - } - } - } - } -} -``` - -Example #2: setting a specific limit -```json -{ - "Swarm": { - "ResourceMgr": { - "Limits": { - "Transient": { - "ConnsOutbound": 256, - } - } - } - } -} -``` - -It is also possible to inspect and adjust some runtime limits via `ipfs swarm stats --help` and `ipfs swarm limit --help`. -Changes made via `ipfs swarm limit` are persisted in `Swarm.ResourceMgr.Limits`. - -Default: `{}` (use the [computed defaults](./libp2p-resource-management.md#computed-default-limits)) - -Type: `object[string->object]` - #### `Swarm.ResourceMgr.Allowlist` A list of multiaddrs that can bypass normal system limits (but are still limited by the allowlist scope). diff --git a/docs/libp2p-resource-management.md b/docs/libp2p-resource-management.md index 255ee669996..b7dbf4baef8 100644 --- a/docs/libp2p-resource-management.md +++ b/docs/libp2p-resource-management.md @@ -1,3 +1,4 @@ + # libp2p Network Resource Manager (`Swarm.ResourceMgr`) ## Purpose @@ -12,32 +13,27 @@ Good places to start are: 3. Understand [how to inspect and change limits](#user-supplied-override-limits) ## Table of Contents - - [Purpose](#purpose) - [🙋 Help! The resource manager is protecting my node but I want to understand more](#-help--the-resource-manager-is-protecting-my-node-but-i-want-to-understand-more) - [Table of Contents](#table-of-contents) - [Levels of Configuration](#levels-of-configuration) - - [Approach](#approach) - - [Computed Default Limits](#computed-default-limits) - - [User Supplied Override Limits](#user-supplied-override-limits) - - [Infinite limits](#infinite-limits) + - [Approach](#approach) + - [Computed Default Limits](#computed-default-limits) + - [User Supplied Override Limits](#user-supplied-override-limits) - [FAQ](#faq) - - [What do these "Protected from exceeding resource limits" log messages mean?](#what-do-these-protected-from-exceeding-resource-limits-log-messages-mean) - - [What are the "Application error 0x0 remote ... cannot reserve ..." messages?](#what-are-the-application-error-0x0-remote--cannot-reserve--messages) - - [How does the resource manager ResourceMgr relate to the connection manager ConnMgr?](#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr) - - [How does one see the Active Limits?](#how-does-one-see-the-active-limits) - - [How does one see the Computed Default Limits?](#how-does-one-see-the-computed-default-limits) - - [How does one monitor libp2p resource usage?](#how-does-one-monitor-libp2p-resource-usage) + - [What do these "Protected from exceeding resource limits" log messages mean?](#what-do-these-protected-from-exceeding-resource-limits-log-messages-mean) + - [How does one see the Active Limits?](#how-does-one-see-the-active-limits) + - [How does one see the Computed Default Limits?](#how-does-one-see-the-computed-default-limits) + - [How does one monitor libp2p resource usage?](#how-does-one-monitor-libp2p-resource-usage) + - [How does the resource manager (ResourceMgr) relate to the connection manager (ConnMgr)?](#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr) + - [What are the "Application error 0x0 (remote) ... cannot reserve ..." messages?](#what-are-the-application-error-0x0-remote--cannot-reserve--messages) - [History](#history) - - ## Levels of Configuration See also the [`Swarm.ResourceMgr` config docs](./config.md#swarmresourcemgr). - ### Approach libp2p's resource manager provides tremendous flexibility but also adds complexity. There are these levels of limit configuration for resource management protection: @@ -45,12 +41,11 @@ libp2p's resource manager provides tremendous flexibility but also adds complexi based on the amount of memory and file descriptors their system has. This should protect the node from many attacks. -1. "Slightly more advanced user" - They can tweak the default limits discussed below. - Where the defaults aren't good enough, a good set of higher-level "knobs" are exposed to satisfy most use cases +2. "Slightly more advanced user" - Where the defaults aren't good enough, a good set of higher-level "knobs" are exposed to satisfy most use cases without requiring users to wade into all the intricacies of libp2p's resource manager. The "knobs"/inputs are `Swarm.ResourceMgr.MaxMemory` and `Swarm.ResourceMgr.MaxFileDescriptors` as described below. -1. "Power user" - They specify overrides to computed default limits via `ipfs swarm limit` and `Swarm.ResourceMgr.Limits`; +3. "Power user" - They [specify override limits](#user-supplied-override-limits) and own their own destiny without Kubo getting in the way. ### Computed Default Limits With the `Swarm.ResourceMgr.MaxMemory` and `Swarm.ResourceMgr.MaxFileDescriptors` inputs defined, @@ -58,7 +53,7 @@ With the `Swarm.ResourceMgr.MaxMemory` and `Swarm.ResourceMgr.MaxFileDescriptors [system](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#the-system-scope), [transient](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#the-transient-scope), and [peer](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#peer-scopes) scopes. -Other scopes are ignored (by being set to "[~infinity](#infinite-limits])". +Other scopes are ignored (by being set to "unlimited"). The reason these scopes are chosen is because: - `system` - This gives us the coarse-grained control we want so we can reason about the system as a whole. @@ -72,13 +67,14 @@ The reason these scopes are chosen is because: (e.g., bug in a peer which is causing it to "misbehave"). In the unintentional case, we want to make sure a "misbehaving" node doesn't consume more resources than necessary. -Within these scopes, limits are just set on -[memory](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#memory), -[file descriptors (FD)](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#file-descriptors), and [*inbound* connections](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#connections). +Within these scopes, limits are set on: +1. [memory](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#memory) +2. [file descriptors (FD)](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#file-descriptors) +3. [*inbound* connections](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#connections). Limits are set based on the `Swarm.ResourceMgr.MaxMemory` and `Swarm.ResourceMgr.MaxFileDescriptors` inputs above. There are also some special cases where minimum values are enforced. -For example, Kubo maintainers have found in practice that it's a footgun to have too low of a value for `Swarm.ResourceMgr.Limits.System.ConnsInbound` and a default minimum is used. (See [core/node/libp2p/rcmgr_defaults.go](https://github.com/ipfs/kubo/blob/master/core/node/libp2p/rcmgr_defaults.go) for specifics.) +For example, Kubo maintainers have found in practice that it's a footgun to have too low of a value for `System.ConnsInbound` and a default minimum is used. (See [core/node/libp2p/rcmgr_defaults.go](https://github.com/ipfs/kubo/blob/master/core/node/libp2p/rcmgr_defaults.go) for specifics.) We trust this node to behave properly and thus don't limit *outbound* connection/stream limits. We apply any limits that libp2p has for its protocols/services @@ -87,29 +83,10 @@ since we assume libp2p knows best here. Source: [core/node/libp2p/rcmgr_defaults.go](https://github.com/ipfs/kubo/blob/master/core/node/libp2p/rcmgr_defaults.go) ### User Supplied Override Limits -Once Kubo has the [Computed Default Limits](#computed-default-limits), it then applies any user-supplied [`Swarm.ResourceMgr.Limits`](https://github.com/ipfs/kubo/blob/master/docs/config.md#swarmresourcemgrlimits) on top. -These become the [active limits](#how-does-one-see-the-active-limits). - -While `Swarm.ResourceMgr.Limits` can be edited directly, it is also possible to use `ipfs swarm limit` command to inspect and tweak specific limits at runtime. - -To see all resources that are close to hitting their respective limit: - -```console -$ ipfs swarm stats --min-used-limit-perc=90 all -``` - -To modify limits for specific scope (e.g. `system`): - -```console -$ ipfs swarm limit system > change.json -$ vi change.json -$ ipfs swarm limit system change.json -``` - -Learn more: `ipfs swarm limit --help` - -### Infinite limits -There isn't a way via config to specify infinite limits (see [go-libp2p#1935](https://github.com/libp2p/go-libp2p/issues/1935)). For example, "-1" is not infinity. To work around this, Kubo uses a magic number of "1000000000" to denote infinity since it's effectively infinite. +A user who wants fine control over the limits used by the go-libp2p resoure manager can specify overrides to the [computed default limits](#computed-default-limits). +This is done by defining limits in ``$IPFS_PATH/libp2p-resource-limit-overrides.json``. +These values trump anything else and are parsed directly by go-libp2p. +(See the [go-libp2p Resource Manager README](https://github.com/libp2p/go-libp2p/blob/master/p2p/host/resource-manager/README.md) for formatting.) ## FAQ @@ -121,58 +98,60 @@ As an example: > Protected from exceeding resource limits 2 times: "system: cannot reserve inbound connection: resource limit exceeded" This means that there were 2 recent occurrences where the libp2p resource manager prevented an inbound connection at the "system" [scope](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#resource-scopes). -Specificaly the ``Swarm.ResourceMgr.Limits.System.ConnsInbound`` [active limit](#how-does-one-see-the-active-limits) was hit. +Specificaly the ``System.ConnsInbound`` limit was hit. -This can be analyzed by viewing the limit with `ipfs swarm limit system` and comparing the usage with `ipfs swarm stats system`. -`ConnsInbound` is likely close or at the limit value. +This can be analyzed by viewing the limit and current usage with `ipfs swarm resources`. +`System.ConnsInbound` is likely close or at the limit value. -The simplest way to identify all resources across all scopes that are close to exceeding their limit is with a command like `ipfs swarm stats --min-used-limit-perc=90 all`. +The simplest way to identify all resources across all scopes that are close to exceeding their limit (>90% usage) is with a command like `ipfs swarm resources | egrep "9.\..%"` Sources: * [kubo resource manager logging](https://github.com/ipfs/kubo/blob/master/core/node/libp2p/rcmgr_logging.go) * [libp2p resource manager messages](https://github.com/libp2p/go-libp2p/blob/master/p2p/host/resource-manager/scope.go) -### What are the "Application error 0x0 (remote) ... cannot reserve ..." messages? -These are messages coming from a *remote* go-libp2p peer (likely another Kubo node) with the resource manager enabled on why it failed to establish a connection. +### How does one see the Active Limits? +A dump of what limits are actually being used by the resource manager ([Computed Default Limits](#computed-default-limits) + [User Supplied Override Limits](#user-supplied-override-limits)) +can be obtained by `ipfs swarm resources`. -This can be confusing, but these `Application error 0x0 (remote) ... cannot reserve ...` messages can occur even if your local node has the resource manager disabled. +### How does one see the Computed Default Limits? +This can be observed [seeing the active limits](#how-does-one-see-the-active-limits) assuming one hasn't detoured into "power user" mode with [User Supplied Override Limits](#user-supplied-override-limits). -You can distinguish resource manager messages originating from your local node if they're from the `resourcemanager` / `libp2p/rcmgr_logging.go` logger -or you see the string that is unique to Kubo (and not in go-libp2p): "Protected from exceeding resource limits". +### How does one monitor libp2p resource usage? + +For [monitoring libp2p resource usage](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#monitoring), +various `*rcmgr_*` metrics can be accessed as the Prometheus endpoint at `{Addresses.API}/debug/metrics/prometheus` (default: `http://127.0.0.1:5001/debug/metrics/prometheus`). +There are also [pre-built Grafana dashboards](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager/obs/grafana-dashboards) that can be added to a Grafana instance. -There is a go-libp2p issue ([#1928](https://github.com/libp2p/go-libp2p/issues/1928)) to make it even clearer that this is an error message originating from a remote peer. +A textual view of current resource usage and a list of services, protocols, and peers can be +obtained via `ipfs swarm stats --help` ### How does the resource manager (ResourceMgr) relate to the connection manager (ConnMgr)? As discussed [here](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#connmanager-vs-resource-manager) these are separate systems in go-libp2p. Kubo performs sanity checks to ensure that some of the hard limits of the ResourceMgr are sufficiently greater than the soft limits of the ConnMgr. -The soft limit of `Swarm.ConnMgr.HighWater` needs to be less than the hard limit `Swarm.ResourceMgr.Limits.System.ConnsInbound` for the configuration to make sense. +The soft limit of `Swarm.ConnMgr.HighWater` needs to be less than the resource manager hard limit `System.ConnsInbound` for the configuration to make sense. This ensures the ConnMgr cleans up connections based on connection priorities before the hard limits of the ResourceMgr are applied. -If `Swarm.ConnMgr.HighWater` is greater than `Swarm.ResourceMgr.Limits.System.ConnsInbound`, +If `Swarm.ConnMgr.HighWater` is greater than resource manager's `System.ConnsInbound`, existing low priority idle connections can prevent new high priority connections from being established. The ResourceMgr doesn't know that the new connection is high priority and simply blocks it because of the limit its enforcing. To ensure the ConnMgr and ResourceMgr are congruent, the ResourceMgr [computed default limts](#computed-default-limits) are adjusted such that: -1. `Swarm.ResourceMgr.Limits.System.ConnsInbound` >= `max(Swarm.ConnMgr.HighWater * 2, DefaultResourceMgrMinInboundConns)` AND -2. `Swarm.ResourceMgr.Limits.System.StreamsInbound` is greater than any new/adjusted `Swarm.ResourceMgr.Limits.System.ConnsInbound` value so that there's enough streams per connection. +1. `System.ConnsInbound` >= `max(Swarm.ConnMgr.HighWater * 2, DefaultResourceMgrMinInboundConns)` AND +2. `System.StreamsInbound` is greater than any new/adjusted `Swarm.ResourceMgr.Limits.System.ConnsInbound` value so that there's enough streams per connection. -### How does one see the Active Limits? -A dump of what limits are actually being used by the resource manager ([Computed Default Limits](#computed-default-limits) + [User Supplied Override Limits](#user-supplied-override-limits)) -can be obtained by `ipfs swarm limit all`. +Source: [core/node/libp2p/rcmgr_defaults.go](https://github.com/ipfs/kubo/blob/master/core/node/libp2p/rcmgr_defaults.go) -### How does one see the Computed Default Limits? -This can be observed with an empty [`Swarm.ResourceMgr.Limits`](https://github.com/ipfs/kubo/blob/master/docs/config.md#swarmresourcemgrlimits) -and then [seeing the active limits](#how-does-one-see-the-active-limits). +### What are the "Application error 0x0 (remote) ... cannot reserve ..." messages? +These are messages coming from old (pre go-libp2p 0.26) *remote* go-libp2p peers (likely another older Kubo node) with the resource manager enabled on why it failed to establish a connection. -### How does one monitor libp2p resource usage? +This can be confusing, but these `Application error 0x0 (remote) ... cannot reserve ...` messages can occur even if your local node has the resource manager disabled. -For [monitoring libp2p resource usage](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager#monitoring), -various `*rcmgr_*` metrics can be accessed as the Prometheus endpoint at `{Addresses.API}/debug/metrics/prometheus` (default: `http://127.0.0.1:5001/debug/metrics/prometheus`). -There are also [pre-built Grafana dashboards](https://github.com/libp2p/go-libp2p/tree/master/p2p/host/resource-manager/obs/grafana-dashboards) that can be added to a Grafana instance. +You can distinguish resource manager messages originating from your local node if they're from the `resourcemanager` / `libp2p/rcmgr_logging.go` logger +or you see the string that is unique to Kubo (and not in go-libp2p): "Protected from exceeding resource limits". + +See more info in this go-libp2p issue ([#1928](https://github.com/libp2p/go-libp2p/issues/1928)). go-libp2p 0.26 / Kubo 0.19 onwards this confusing error message was removed. -A textual view of current resource usage and a list of services, protocols, and peers can be -obtained via `ipfs swarm stats --help` ## History -Kubo first [exposed this functionality in Kubo 0.13](./changelogs/v0.13.md#-libp2p-network-resource-manager-swarmresourcemgr), but it was disabled by default. It was then enabled by default in [Kubo 0.17](./changelogs/v0.17.md#libp2p-resource-management-enabled-by-default). Until that point, Kubo was vulnerable to unbound resource usage which could bring down nodes. Introducing limits like this by default after the fact is tricky, which is why there have been changes and improvements afterwards. +Kubo first [exposed this functionality in Kubo 0.13](./changelogs/v0.13.md#-libp2p-network-resource-manager-swarmresourcemgr), but it was disabled by default. It was then enabled by default in [Kubo 0.17](./changelogs/v0.17.md#libp2p-resource-management-enabled-by-default). Until that point, Kubo was vulnerable to unbound resource usage which could bring down nodes. Introducing limits like this by default after the fact is tricky, which is why there have been changes and improvements afterwards. The general trend since 0.17 with (0.18)[./changeloges/v0.18.md#improving-libp2p-resource-management-integration] and 0.19 has been to simplify and provide less options (and footguns!) for users and better documentation. From 23379d8d601e1beb8db929ca9ca154e0ddf3a5e4 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Thu, 2 Mar 2023 09:29:12 +0100 Subject: [PATCH 29/93] chore: update go-unixfs v0.4.4 Include missing error handling. --- docs/examples/kubo-as-a-library/go.mod | 2 +- docs/examples/kubo-as-a-library/go.sum | 4 ++-- go.mod | 2 +- go.sum | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/examples/kubo-as-a-library/go.mod b/docs/examples/kubo-as-a-library/go.mod index c3e8e16d1e8..9bddae4de4e 100644 --- a/docs/examples/kubo-as-a-library/go.mod +++ b/docs/examples/kubo-as-a-library/go.mod @@ -103,7 +103,7 @@ require ( github.com/ipfs/go-namesys v0.7.0 // indirect github.com/ipfs/go-path v0.3.1 // indirect github.com/ipfs/go-peertaskqueue v0.8.1 // indirect - github.com/ipfs/go-unixfs v0.4.3 // indirect + github.com/ipfs/go-unixfs v0.4.4 // indirect github.com/ipfs/go-unixfsnode v1.5.2 // indirect github.com/ipfs/go-verifcid v0.0.2 // indirect github.com/ipld/edelweiss v0.2.0 // indirect diff --git a/docs/examples/kubo-as-a-library/go.sum b/docs/examples/kubo-as-a-library/go.sum index a5b30e5d700..c56c5776c42 100644 --- a/docs/examples/kubo-as-a-library/go.sum +++ b/docs/examples/kubo-as-a-library/go.sum @@ -606,8 +606,8 @@ github.com/ipfs/go-peertaskqueue v0.8.1 h1:YhxAs1+wxb5jk7RvS0LHdyiILpNmRIRnZVzte github.com/ipfs/go-peertaskqueue v0.8.1/go.mod h1:Oxxd3eaK279FxeydSPPVGHzbwVeHjatZ2GA8XD+KbPU= github.com/ipfs/go-unixfs v0.2.4/go.mod h1:SUdisfUjNoSDzzhGVxvCL9QO/nKdwXdr+gbMUdqcbYw= github.com/ipfs/go-unixfs v0.3.1/go.mod h1:h4qfQYzghiIc8ZNFKiLMFWOTzrWIAtzYQ59W/pCFf1o= -github.com/ipfs/go-unixfs v0.4.3 h1:EdDc1sNZNFDUlo4UrVAvvAofVI5EwTnKu8Nv8mgXkWQ= -github.com/ipfs/go-unixfs v0.4.3/go.mod h1:TSG7G1UuT+l4pNj91raXAPkX0BhJi3jST1FDTfQ5QyM= +github.com/ipfs/go-unixfs v0.4.4 h1:D/dLBOJgny5ZLIur2vIXVQVW0EyDHdOMBDEhgHrt6rY= +github.com/ipfs/go-unixfs v0.4.4/go.mod h1:TSG7G1UuT+l4pNj91raXAPkX0BhJi3jST1FDTfQ5QyM= github.com/ipfs/go-unixfsnode v1.1.2/go.mod h1:5dcE2x03pyjHk4JjamXmunTMzz+VUtqvPwZjIEkfV6s= github.com/ipfs/go-unixfsnode v1.5.2 h1:CvsiTt58W2uR5dD8bqQv+aAY0c1qolmXmSyNbPHYiew= github.com/ipfs/go-unixfsnode v1.5.2/go.mod h1:NlOebRwYx8lMCNMdhAhEspYPBD3obp7TE0LvBqHY+ks= diff --git a/go.mod b/go.mod index ec0e3e8a5ed..b53ff3b0e3e 100644 --- a/go.mod +++ b/go.mod @@ -55,7 +55,7 @@ require ( github.com/ipfs/go-namesys v0.7.0 github.com/ipfs/go-path v0.3.1 github.com/ipfs/go-pinning-service-http-client v0.1.2 - github.com/ipfs/go-unixfs v0.4.3 + github.com/ipfs/go-unixfs v0.4.4 github.com/ipfs/go-unixfsnode v1.5.2 github.com/ipfs/go-verifcid v0.0.2 github.com/ipfs/interface-go-ipfs-core v0.11.0 diff --git a/go.sum b/go.sum index 9f666f40511..90a843a3b51 100644 --- a/go.sum +++ b/go.sum @@ -632,8 +632,8 @@ github.com/ipfs/go-pinning-service-http-client v0.1.2 h1:jdr7KelhL9gNHTU8jbqPMwI github.com/ipfs/go-pinning-service-http-client v0.1.2/go.mod h1:6wd5mjYhXJTiWU8b4RSWPpWdlzE5/csoXV0dWWMjun4= github.com/ipfs/go-unixfs v0.2.4/go.mod h1:SUdisfUjNoSDzzhGVxvCL9QO/nKdwXdr+gbMUdqcbYw= github.com/ipfs/go-unixfs v0.3.1/go.mod h1:h4qfQYzghiIc8ZNFKiLMFWOTzrWIAtzYQ59W/pCFf1o= -github.com/ipfs/go-unixfs v0.4.3 h1:EdDc1sNZNFDUlo4UrVAvvAofVI5EwTnKu8Nv8mgXkWQ= -github.com/ipfs/go-unixfs v0.4.3/go.mod h1:TSG7G1UuT+l4pNj91raXAPkX0BhJi3jST1FDTfQ5QyM= +github.com/ipfs/go-unixfs v0.4.4 h1:D/dLBOJgny5ZLIur2vIXVQVW0EyDHdOMBDEhgHrt6rY= +github.com/ipfs/go-unixfs v0.4.4/go.mod h1:TSG7G1UuT+l4pNj91raXAPkX0BhJi3jST1FDTfQ5QyM= github.com/ipfs/go-unixfsnode v1.1.2/go.mod h1:5dcE2x03pyjHk4JjamXmunTMzz+VUtqvPwZjIEkfV6s= github.com/ipfs/go-unixfsnode v1.5.2 h1:CvsiTt58W2uR5dD8bqQv+aAY0c1qolmXmSyNbPHYiew= github.com/ipfs/go-unixfsnode v1.5.2/go.mod h1:NlOebRwYx8lMCNMdhAhEspYPBD3obp7TE0LvBqHY+ks= From fea25f7ab10463f3dd0e4dc1a01d8d729d0281f0 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Thu, 2 Mar 2023 09:29:40 +0100 Subject: [PATCH 30/93] chore: update golang.org/x/net to v0.7.0 Include fix for https://pkg.go.dev/vuln/GO-2023-1571 (this impact us in the DOH handler). --- docs/examples/kubo-as-a-library/go.mod | 6 +++--- docs/examples/kubo-as-a-library/go.sum | 12 ++++++------ go.mod | 8 ++++---- go.sum | 16 ++++++++-------- 4 files changed, 21 insertions(+), 21 deletions(-) diff --git a/docs/examples/kubo-as-a-library/go.mod b/docs/examples/kubo-as-a-library/go.mod index 9bddae4de4e..056aea33467 100644 --- a/docs/examples/kubo-as-a-library/go.mod +++ b/docs/examples/kubo-as-a-library/go.mod @@ -198,10 +198,10 @@ require ( golang.org/x/crypto v0.5.0 // indirect golang.org/x/exp v0.0.0-20230129154200-a960b3787bd2 // indirect golang.org/x/mod v0.7.0 // indirect - golang.org/x/net v0.5.0 // indirect + golang.org/x/net v0.7.0 // indirect golang.org/x/sync v0.1.0 // indirect - golang.org/x/sys v0.4.0 // indirect - golang.org/x/text v0.6.0 // indirect + golang.org/x/sys v0.5.0 // indirect + golang.org/x/text v0.7.0 // indirect golang.org/x/tools v0.3.0 // indirect golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1 // indirect diff --git a/docs/examples/kubo-as-a-library/go.sum b/docs/examples/kubo-as-a-library/go.sum index c56c5776c42..8a07bfbe87a 100644 --- a/docs/examples/kubo-as-a-library/go.sum +++ b/docs/examples/kubo-as-a-library/go.sum @@ -1526,8 +1526,8 @@ golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985/go.mod h1:9nx3DQGgdP8bBQD5qx golang.org/x/net v0.0.0-20210917221730-978cfadd31cf/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= -golang.org/x/net v0.5.0 h1:GyT4nK/YDHSqa1c4753ouYCDajOYKTja9Xb/OHtgvSw= -golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws= +golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g= +golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= @@ -1635,8 +1635,8 @@ golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220114195835-da31bd327af9/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.4.0 h1:Zr2JFtRQNX3BCZ8YtxRE9hNJYC8J6I1MVbMg6owUp18= -golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= @@ -1648,8 +1648,8 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.6.0 h1:3XmdazWV+ubf7QgHSTWeykHOci5oeekaGJBLkrkaw4k= -golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= diff --git a/go.mod b/go.mod index b53ff3b0e3e..2892d37401e 100644 --- a/go.mod +++ b/go.mod @@ -109,7 +109,7 @@ require ( golang.org/x/exp v0.0.0-20230129154200-a960b3787bd2 golang.org/x/mod v0.7.0 golang.org/x/sync v0.1.0 - golang.org/x/sys v0.4.0 + golang.org/x/sys v0.5.0 ) require ( @@ -228,10 +228,10 @@ require ( go.uber.org/atomic v1.10.0 // indirect go.uber.org/multierr v1.9.0 // indirect go4.org v0.0.0-20200411211856-f5505b9728dd // indirect - golang.org/x/net v0.5.0 // indirect + golang.org/x/net v0.7.0 // indirect golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b // indirect - golang.org/x/term v0.4.0 // indirect - golang.org/x/text v0.6.0 // indirect + golang.org/x/term v0.5.0 // indirect + golang.org/x/text v0.7.0 // indirect golang.org/x/tools v0.3.0 // indirect golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect google.golang.org/appengine v1.6.6 // indirect diff --git a/go.sum b/go.sum index 90a843a3b51..6f7800a2e2a 100644 --- a/go.sum +++ b/go.sum @@ -1590,8 +1590,8 @@ golang.org/x/net v0.0.0-20210917221730-978cfadd31cf/go.mod h1:9nx3DQGgdP8bBQD5qx golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220624214902-1bab6f366d9e/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.5.0 h1:GyT4nK/YDHSqa1c4753ouYCDajOYKTja9Xb/OHtgvSw= -golang.org/x/net v0.5.0/go.mod h1:DivGGAXEgPSlEBzxGzZI+ZLohi+xUj054jfeKui00ws= +golang.org/x/net v0.7.0 h1:rJrUqqhjsgNp7KqAIc25s9pZnjU7TUcSY7HcVZjdn1g= +golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= @@ -1702,13 +1702,13 @@ golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.4.0 h1:Zr2JFtRQNX3BCZ8YtxRE9hNJYC8J6I1MVbMg6owUp18= -golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.4.0 h1:O7UWfv5+A2qiuulQk30kVinPoMtoIPeVaKLEgLpVkvg= -golang.org/x/term v0.4.0/go.mod h1:9P2UbLfCdcvo3p/nzKvsmas4TnlujnuoV9hGgYzW1lQ= +golang.org/x/term v0.5.0 h1:n2a8QNdAb0sZNpU9R1ALUXBbY+w51fCQDN+7EdxNBsY= +golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -1717,8 +1717,8 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.6.0 h1:3XmdazWV+ubf7QgHSTWeykHOci5oeekaGJBLkrkaw4k= -golang.org/x/text v0.6.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= +golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo= +golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= From 7aed2163d3e2deb4a23c462df3a1d561fcd9595a Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Mon, 6 Mar 2023 12:30:04 +0100 Subject: [PATCH 31/93] fix: t0116-gateway-cache.sh --- test/sharness/t0116-gateway-cache.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/sharness/t0116-gateway-cache.sh b/test/sharness/t0116-gateway-cache.sh index 508fc73c288..0cb1a94eb00 100755 --- a/test/sharness/t0116-gateway-cache.sh +++ b/test/sharness/t0116-gateway-cache.sh @@ -204,7 +204,7 @@ test_expect_success "Prepare IPNS unixfs content path for testing" ' grep -E "< Etag: \"DirIndex-.+_CID-${ROOT3_CID}\"" curl_ipfs_dir_listing_output ' test_expect_success "GET /ipns/ dir response has special Etag for generated dir listing" ' - test_should_contain "< Etag: \"DirIndex" curl_ipfs_dir_listing_output && + test_should_contain "< Etag: \"DirIndex" curl_ipns_dir_listing_output && grep -E "< Etag: \"DirIndex-.+_CID-${ROOT3_CID}\"" curl_ipns_dir_listing_output ' From 7986196414f37f79d35cd4183af8d56a53b9ec48 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Wed, 1 Mar 2023 15:29:45 +0100 Subject: [PATCH 32/93] feat: Reduce RM code footprint Co-Authored-By: Antonio Navarro Perez --- .circleci/main.yml | 2 +- .github/workflows/build.yml | 1 + config/swarm.go | 6 +- config/types.go | 26 + core/commands/commands_test.go | 3 +- core/commands/swarm.go | 181 ++----- core/node/groups.go | 33 +- core/node/libp2p/rcmgr.go | 790 +++++++++++------------------ core/node/libp2p/rcmgr_defaults.go | 174 +++---- core/node/libp2p/rcmgr_test.go | 12 - core/node/storage.go | 3 +- go.mod | 2 +- repo/fsrepo/fsrepo.go | 42 +- repo/mock.go | 5 + repo/repo.go | 5 + test/cli/basic_commands_test.go | 1 + test/cli/harness/node.go | 33 ++ test/cli/rcmgr_test.go | 276 ++++------ test/sharness/t0060-daemon.sh | 5 +- 19 files changed, 644 insertions(+), 956 deletions(-) delete mode 100644 core/node/libp2p/rcmgr_test.go diff --git a/.circleci/main.yml b/.circleci/main.yml index b611026927a..b6be1d91464 100644 --- a/.circleci/main.yml +++ b/.circleci/main.yml @@ -309,7 +309,7 @@ jobs: - run: name: Cloning command: | - git clone https://github.com/ipfs/go-ipfs-http-client.git + git clone https://github.com/ipfs/go-ipfs-http-client.git -b bump-for-rcmgr-last-push git -C go-ipfs-http-client log -1 - restore_cache: keys: diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index b6bc3c595f1..2994d7d1ad0 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -143,6 +143,7 @@ jobs: with: repository: ipfs/go-ipfs-http-client path: go-ipfs-http-client + ref: bump-for-rcmgr-last-push - uses: protocol/cache-go-action@v1 with: name: ${{ github.job }} diff --git a/config/swarm.go b/config/swarm.go index abff9142207..d7e40e27cb6 100644 --- a/config/swarm.go +++ b/config/swarm.go @@ -1,7 +1,5 @@ package config -import rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" - type SwarmConfig struct { // AddrFilters specifies a set libp2p addresses that we should never // dial or receive connections from. @@ -141,8 +139,8 @@ type ConnMgr struct { // type ResourceMgr struct { // Enables the Network Resource Manager feature, default to on. - Enabled Flag `json:",omitempty"` - Limits *rcmgr.PartialLimitConfig `json:",omitempty"` + Enabled Flag `json:",omitempty"` + Limits swarmLimits `json:",omitempty"` MaxMemory *OptionalString `json:",omitempty"` MaxFileDescriptors *OptionalInteger `json:",omitempty"` diff --git a/config/types.go b/config/types.go index f753827ab1d..3a0d4f4b3b2 100644 --- a/config/types.go +++ b/config/types.go @@ -1,8 +1,10 @@ package config import ( + "bytes" "encoding/json" "fmt" + "io" "strings" "time" ) @@ -412,3 +414,27 @@ func (p OptionalString) String() string { var _ json.Unmarshaler = (*OptionalInteger)(nil) var _ json.Marshaler = (*OptionalInteger)(nil) + +type swarmLimits struct{} + +var _ json.Unmarshaler = swarmLimits{} + +func (swarmLimits) UnmarshalJSON(b []byte) error { + d := json.NewDecoder(bytes.NewReader(b)) + for { + switch tok, err := d.Token(); err { + case io.EOF: + return nil + case nil: + switch tok { + case json.Delim('{'), json.Delim('}'): + // accept empty objects + continue + } + //nolint + return fmt.Errorf("The Swarm.ResourceMgr.Limits configuration has been removed in Kubo 0.19 and should be empty or not present. To set custom libp2p limits, read https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#user-supplied-override-limits") + default: + return err + } + } +} diff --git a/core/commands/commands_test.go b/core/commands/commands_test.go index 8f94e5d6413..bf1b7645085 100644 --- a/core/commands/commands_test.go +++ b/core/commands/commands_test.go @@ -248,13 +248,12 @@ func TestCommands(t *testing.T) { "/swarm/filters", "/swarm/filters/add", "/swarm/filters/rm", - "/swarm/limit", "/swarm/peers", "/swarm/peering", "/swarm/peering/add", "/swarm/peering/ls", "/swarm/peering/rm", - "/swarm/stats", + "/swarm/resources", "/tar", "/tar/add", "/tar/cat", diff --git a/core/commands/swarm.go b/core/commands/swarm.go index a4bb705f983..7d5ae96afc0 100644 --- a/core/commands/swarm.go +++ b/core/commands/swarm.go @@ -1,7 +1,6 @@ package commands import ( - "bytes" "context" "encoding/json" "errors" @@ -9,10 +8,11 @@ import ( "io" "path" "sort" + "strconv" "sync" + "text/tabwriter" "time" - "github.com/ipfs/go-libipfs/files" "github.com/ipfs/kubo/commands" "github.com/ipfs/kubo/config" "github.com/ipfs/kubo/core/commands/cmdenv" @@ -57,8 +57,8 @@ ipfs peers in the internet. "filters": swarmFiltersCmd, "peers": swarmPeersCmd, "peering": swarmPeeringCmd, - "stats": swarmStatsCmd, // libp2p Network Resource Manager - "limit": swarmLimitCmd, // libp2p Network Resource Manager + "resources": swarmResourcesCmd, // libp2p Network Resource Manager + }, } @@ -323,30 +323,15 @@ var swarmPeersCmd = &cmds.Command{ Type: connInfos{}, } -var swarmStatsCmd = &cmds.Command{ +var swarmResourcesCmd = &cmds.Command{ Status: cmds.Experimental, Helptext: cmds.HelpText{ - Tagline: "Report resource usage for a scope.", - LongDescription: `Report resource usage for a scope. -The scope can be one of the following: -- system -- reports the system aggregate resource usage. -- transient -- reports the transient resource usage. -- svc: -- reports the resource usage of a specific service. -- proto: -- reports the resource usage of a specific protocol. -- peer: -- reports the resource usage of a specific peer. -- all -- reports the resource usage for all currently active scopes. - -The output of this command is JSON. - -To see all resources that are close to hitting their respective limit, one can do something like: - ipfs swarm stats --min-used-limit-perc=90 all + Tagline: "Get a summary of all resources accounted for by the libp2p Resource Manager.", + LongDescription: ` +Get a summary of all resources accounted for by the libp2p Resource Manager. +This includes the limits and the usage against those limits. +This can output a human readable table and JSON encoding. `}, - Arguments: []cmds.Argument{ - cmds.StringArg("scope", true, false, "scope of the stat report"), - }, - Options: []cmds.Option{ - cmds.IntOption(swarmUsedResourcesPercentageName, "Only display resources that are using above the specified percentage of their respective limit"), - }, Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error { node, err := cmdenv.GetNode(env) if err != nil { @@ -357,128 +342,68 @@ To see all resources that are close to hitting their respective limit, one can d return libp2p.ErrNoResourceMgr } - if len(req.Arguments) != 1 { - return fmt.Errorf("must specify exactly one scope") - } - - percentage, _ := req.Options[swarmUsedResourcesPercentageName].(int) - scope := req.Arguments[0] - - if percentage != 0 && scope != "all" { - return fmt.Errorf("%q can only be used when scope is %q", swarmUsedResourcesPercentageName, "all") - } - - result, err := libp2p.NetStat(node.ResourceManager, scope, percentage) + cfg, err := node.Repo.Config() if err != nil { return err } - b := new(bytes.Buffer) - enc := json.NewEncoder(b) - err = enc.Encode(result) + userResourceOverrides, err := node.Repo.UserResourceOverrides() if err != nil { return err } - return cmds.EmitOnce(res, b) - }, - Encoders: cmds.EncoderMap{ - cmds.Text: HumanJSONEncoder, - }, -} - -var swarmLimitCmd = &cmds.Command{ - Status: cmds.Experimental, - Helptext: cmds.HelpText{ - Tagline: "Get or set resource limits for a scope.", - LongDescription: `Get or set resource limits for a scope. -The scope can be one of the following: -- all -- all limits actually being applied. -- system -- limits for the system aggregate resource usage. -- transient -- limits for the transient resource usage. -- svc: -- limits for the resource usage of a specific service. -- proto: -- limits for the resource usage of a specific protocol. -- peer: -- limits for the resource usage of a specific peer. - -The output of this command is JSON. - -It is possible to use this command to inspect and tweak limits at runtime: - - $ ipfs swarm limit system > limit.json - $ vi limit.json - $ ipfs swarm limit system limit.json -Changes made via command line are persisted in the Swarm.ResourceMgr.Limits field of the $IPFS_PATH/config file. -`}, - Arguments: []cmds.Argument{ - cmds.StringArg("scope", true, false, "scope of the limit"), - cmds.FileArg("limit.json", false, false, "limits to be set").EnableStdin(), - }, - Options: []cmds.Option{ - cmds.BoolOption(swarmResetLimitsOptionName, "reset limit to default"), - }, - Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error { - node, err := cmdenv.GetNode(env) + // FIXME: we shouldn't recompute limits, either save them or load them from libp2p (https://github.com/libp2p/go-libp2p/issues/2166) + limitConfig, _, err := libp2p.LimitConfig(cfg.Swarm, userResourceOverrides) if err != nil { return err } - if node.ResourceManager == nil { + rapi, ok := node.ResourceManager.(rcmgr.ResourceManagerState) + if !ok { // NullResourceManager return libp2p.ErrNoResourceMgr } - scope := req.Arguments[0] - - // set scope limit to new values (when limit.json is passed as a second arg) - if req.Files != nil { - var newLimit rcmgr.ResourceLimits - it := req.Files.Entries() - if it.Next() { - file := files.FileFromEntry(it) - if file == nil { - return errors.New("expected a JSON file") - } - - r := io.LimitReader(file, 32*1024*1024) // 32MiB - - if err := json.NewDecoder(r).Decode(&newLimit); err != nil { - return fmt.Errorf("decoding JSON as ResourceMgrScopeConfig: %w", err) + return cmds.EmitOnce(res, libp2p.MergeLimitsAndStatsIntoLimitsConfigAndUsage(limitConfig, rapi.Stat())) + }, + Encoders: cmds.EncoderMap{ + cmds.JSON: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, limitsAndUsage libp2p.LimitsConfigAndUsage) error { + return json.NewEncoder(w).Encode(limitsAndUsage) + }), + cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, limitsAndUsage libp2p.LimitsConfigAndUsage) error { + tw := tabwriter.NewWriter(w, 20, 8, 0, '\t', 0) + defer tw.Flush() + + fmt.Fprintf(tw, "%s\t%s\t%s\t%s\t%s\t\n", "Scope", "Limit Name", "Limit Value", "Limit Usage Amount", "Limit Usage Percent") + for _, ri := range libp2p.LimitConfigsToInfo(limitsAndUsage) { + var limit, percentage string + switch ri.LimitValue { + case rcmgr.Unlimited64: + limit = "unlimited" + percentage = "n/a" + case rcmgr.BlockAllLimit64: + limit = "blockAll" + percentage = "n/a" + default: + limit = strconv.FormatInt(int64(ri.LimitValue), 10) + if ri.CurrentUsage == 0 { + percentage = "0%" + } else { + percentage = strconv.FormatFloat(float64(ri.CurrentUsage)/float64(ri.LimitValue)*100, 'f', 1, 64) + "%" + } } - return libp2p.NetSetLimit(node.ResourceManager, node.Repo, scope, newLimit) + fmt.Fprintf(tw, "%s\t%s\t%s\t%d\t%s\t\n", + ri.ScopeName, + ri.LimitName, + limit, + ri.CurrentUsage, + percentage, + ) } - if err := it.Err(); err != nil { - return fmt.Errorf("error opening limit JSON file: %w", err) - } - } - - var result interface{} - switch _, reset := req.Options[swarmResetLimitsOptionName]; { - case reset: - result, err = libp2p.NetResetLimit(node.ResourceManager, node.Repo, scope) - case scope == "all": - result, err = libp2p.NetLimitAll(node.ResourceManager) - default: - // get scope limit - result, err = libp2p.NetLimit(node.ResourceManager, scope) - } - if err != nil { - return err - } - if base, ok := result.(rcmgr.BaseLimit); ok { - result = base.ToResourceLimits() - } - - b := new(bytes.Buffer) - enc := json.NewEncoder(b) - err = enc.Encode(result) - if err != nil { - return err - } - return cmds.EmitOnce(res, b) - }, - Encoders: cmds.EncoderMap{ - cmds.Text: HumanJSONEncoder, + return nil + }), }, + Type: libp2p.LimitsConfigAndUsage{}, } type streamInfo struct { diff --git a/core/node/groups.go b/core/node/groups.go index e640feff1ab..866204ce36b 100644 --- a/core/node/groups.go +++ b/core/node/groups.go @@ -6,21 +6,19 @@ import ( "fmt" "time" + "github.com/dustin/go-humanize" blockstore "github.com/ipfs/go-ipfs-blockstore" + offline "github.com/ipfs/go-ipfs-exchange-offline" util "github.com/ipfs/go-ipfs-util" "github.com/ipfs/go-log" + uio "github.com/ipfs/go-unixfs/io" "github.com/ipfs/kubo/config" + "github.com/ipfs/kubo/core/node/libp2p" + "github.com/ipfs/kubo/p2p" pubsub "github.com/libp2p/go-libp2p-pubsub" "github.com/libp2p/go-libp2p-pubsub/timecache" "github.com/libp2p/go-libp2p/core/peer" - - "github.com/ipfs/kubo/core/node/libp2p" - "github.com/ipfs/kubo/p2p" - - offline "github.com/ipfs/go-ipfs-exchange-offline" - uio "github.com/ipfs/go-unixfs/io" - - "github.com/dustin/go-humanize" + rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" "go.uber.org/fx" ) @@ -37,7 +35,7 @@ var BaseLibP2P = fx.Options( fx.Invoke(libp2p.PNetChecker), ) -func LibP2P(bcfg *BuildCfg, cfg *config.Config) fx.Option { +func LibP2P(bcfg *BuildCfg, cfg *config.Config, userResourceOverrides rcmgr.PartialLimitConfig) fx.Option { var connmgr fx.Option // set connmgr based on Swarm.ConnMgr.Type @@ -150,7 +148,7 @@ func LibP2P(bcfg *BuildCfg, cfg *config.Config) fx.Option { fx.Provide(libp2p.UserAgent()), // Services (resource management) - fx.Provide(libp2p.ResourceManager(cfg.Swarm)), + fx.Provide(libp2p.ResourceManager(cfg.Swarm, userResourceOverrides)), fx.Provide(libp2p.AddrFilters(cfg.Swarm.AddrFilters)), fx.Provide(libp2p.AddrsFactory(cfg.Addresses.Announce, cfg.Addresses.AppendAnnounce, cfg.Addresses.NoAnnounce)), fx.Provide(libp2p.SmuxTransport(cfg.Swarm.Transports)), @@ -249,7 +247,7 @@ var IPNS = fx.Options( ) // Online groups online-only units -func Online(bcfg *BuildCfg, cfg *config.Config) fx.Option { +func Online(bcfg *BuildCfg, cfg *config.Config, userResourceOverrides rcmgr.PartialLimitConfig) fx.Option { // Namesys params @@ -303,7 +301,7 @@ func Online(bcfg *BuildCfg, cfg *config.Config) fx.Option { fx.Provide(p2p.New), - LibP2P(bcfg, cfg), + LibP2P(bcfg, cfg, userResourceOverrides), OnlineProviders( cfg.Experimental.StrategicProviding, cfg.Experimental.AcceleratedDHTClient, @@ -340,9 +338,9 @@ var Core = fx.Options( fx.Provide(Files), ) -func Networked(bcfg *BuildCfg, cfg *config.Config) fx.Option { +func Networked(bcfg *BuildCfg, cfg *config.Config, userResourceOverrides rcmgr.PartialLimitConfig) fx.Option { if bcfg.Online { - return Online(bcfg, cfg) + return Online(bcfg, cfg, userResourceOverrides) } return Offline(cfg) } @@ -358,6 +356,11 @@ func IPFS(ctx context.Context, bcfg *BuildCfg) fx.Option { return bcfgOpts // error } + userResourceOverrides, err := bcfg.Repo.UserResourceOverrides() + if err != nil { + return fx.Error(err) + } + // Auto-sharding settings shardSizeString := cfg.Internal.UnixFSShardingSizeThreshold.WithDefault("256kiB") shardSizeInt, err := humanize.ParseBytes(shardSizeString) @@ -381,7 +384,7 @@ func IPFS(ctx context.Context, bcfg *BuildCfg) fx.Option { Storage(bcfg, cfg), Identity(cfg), IPNS, - Networked(bcfg, cfg), + Networked(bcfg, cfg, userResourceOverrides), Core, ) diff --git a/core/node/libp2p/rcmgr.go b/core/node/libp2p/rcmgr.go index 0d7ac761c17..54bff2852df 100644 --- a/core/node/libp2p/rcmgr.go +++ b/core/node/libp2p/rcmgr.go @@ -2,10 +2,10 @@ package libp2p import ( "context" + "encoding/json" "fmt" "os" "path/filepath" - "strings" "github.com/benbjohnson/clock" logging "github.com/ipfs/go-log/v2" @@ -17,21 +17,17 @@ import ( rcmgrObs "github.com/libp2p/go-libp2p/p2p/host/resource-manager/obs" "github.com/multiformats/go-multiaddr" "go.uber.org/fx" - "golang.org/x/exp/constraints" "github.com/ipfs/kubo/config" "github.com/ipfs/kubo/core/node/helpers" "github.com/ipfs/kubo/repo" ) -// FIXME(@Jorropo): for go-libp2p v0.26.0 use .MustConcrete and .MustBaseLimit instead of .Build(rcmgr.BaseLimit{}). - -const NetLimitDefaultFilename = "limit.json" const NetLimitTraceFilename = "rcmgr.json.gz" var ErrNoResourceMgr = fmt.Errorf("missing ResourceMgr: make sure the daemon is running with Swarm.ResourceMgr.Enabled") -func ResourceManager(cfg config.SwarmConfig) interface{} { +func ResourceManager(cfg config.SwarmConfig, userResourceOverrides rcmgr.PartialLimitConfig) interface{} { return func(mctx helpers.MetricsCtx, lc fx.Lifecycle, repo repo.Repo) (network.ResourceManager, Libp2pOpts, error) { var manager network.ResourceManager var opts Libp2pOpts @@ -54,32 +50,25 @@ func ResourceManager(cfg config.SwarmConfig) interface{} { return nil, opts, fmt.Errorf("opening IPFS_PATH: %w", err) } - var limitConfig rcmgr.ConcreteLimitConfig - defaultComputedLimitConfig, err := createDefaultLimitConfig(cfg) + limitConfig, msg, err := LimitConfig(cfg, userResourceOverrides) if err != nil { - return nil, opts, err + return nil, opts, fmt.Errorf("creating final Resource Manager config: %w", err) } - // The logic for defaults and overriding with specified SwarmConfig.ResourceMgr.Limits - // is documented in docs/config.md. - // Any changes here should be reflected there. - if cfg.ResourceMgr.Limits != nil { - userSuppliedOverrideLimitConfig := *cfg.ResourceMgr.Limits - // This effectively overrides the computed default LimitConfig with any non-zero values from cfg.ResourceMgr.Limits. - // Because of how how Apply works, any 0 value for a user supplied override - // will be overriden with a computed default value. - // There currently isn't a way for a user to supply a 0-value override. - limitConfig = userSuppliedOverrideLimitConfig.Build(defaultComputedLimitConfig) - } else { - limitConfig = defaultComputedLimitConfig + if !isPartialConfigEmpty(userResourceOverrides) { + fmt.Print(` +libp2p-resource-limit-overrides.json has been loaded, "default" fields will be +filled in with autocomputed defaults. +`) } - if err := ensureConnMgrMakeSenseVsResourceMgr(limitConfig, cfg.ConnMgr); err != nil { + // We want to see this message on startup, that's why we are using fmt instead of log. + fmt.Print(msg) + + if err := ensureConnMgrMakeSenseVsResourceMgr(limitConfig, cfg); err != nil { return nil, opts, err } - limiter := rcmgr.NewFixedLimiter(limitConfig) - str, err := rcmgrObs.NewStatsTraceReporter() if err != nil { return nil, opts, err @@ -106,6 +95,8 @@ func ResourceManager(cfg config.SwarmConfig) interface{} { ropts = append(ropts, rcmgr.WithTrace(traceFilePath)) } + limiter := rcmgr.NewFixedLimiter(limitConfig) + manager, err = rcmgr.NewResourceManager(limiter, ropts...) if err != nil { return nil, opts, fmt.Errorf("creating libp2p resource manager: %w", err) @@ -133,540 +124,363 @@ func ResourceManager(cfg config.SwarmConfig) interface{} { } } -type notOmitEmptyResourceLimit struct { - Streams rcmgr.LimitVal - StreamsInbound rcmgr.LimitVal - StreamsOutbound rcmgr.LimitVal - Conns rcmgr.LimitVal - ConnsInbound rcmgr.LimitVal - ConnsOutbound rcmgr.LimitVal - FD rcmgr.LimitVal - Memory rcmgr.LimitVal64 -} - -func resourceLimitsToNotOmitEmpty(r rcmgr.ResourceLimits) notOmitEmptyResourceLimit { - return notOmitEmptyResourceLimit{ - Streams: r.Streams, - StreamsInbound: r.StreamsInbound, - StreamsOutbound: r.StreamsOutbound, - Conns: r.Conns, - ConnsInbound: r.ConnsInbound, - ConnsOutbound: r.ConnsOutbound, - FD: r.FD, - Memory: r.Memory, +func isPartialConfigEmpty(cfg rcmgr.PartialLimitConfig) bool { + var emptyResourceConfig rcmgr.ResourceLimits + if cfg.System != emptyResourceConfig || + cfg.Transient != emptyResourceConfig || + cfg.AllowlistedSystem != emptyResourceConfig || + cfg.AllowlistedTransient != emptyResourceConfig || + cfg.ServiceDefault != emptyResourceConfig || + cfg.ServicePeerDefault != emptyResourceConfig || + cfg.ProtocolDefault != emptyResourceConfig || + cfg.ProtocolPeerDefault != emptyResourceConfig || + cfg.PeerDefault != emptyResourceConfig || + cfg.Conn != emptyResourceConfig || + cfg.Stream != emptyResourceConfig { + return false } -} - -type NetStatOut struct { - System *notOmitEmptyResourceLimit `json:",omitempty"` - Transient *notOmitEmptyResourceLimit `json:",omitempty"` - Services map[string]notOmitEmptyResourceLimit `json:",omitempty"` - Protocols map[string]notOmitEmptyResourceLimit `json:",omitempty"` - Peers map[string]notOmitEmptyResourceLimit `json:",omitempty"` -} - -func NetStat(mgr network.ResourceManager, scope string, percentage int) (NetStatOut, error) { - var err error - var result NetStatOut - switch { - case scope == "all": - rapi, ok := mgr.(rcmgr.ResourceManagerState) - if !ok { // NullResourceManager - return result, ErrNoResourceMgr - } - - limits, err := NetLimitAll(mgr) - if err != nil { - return result, err + for _, v := range cfg.Service { + if v != emptyResourceConfig { + return false } - - stat := rapi.Stat() - if s := scopeToLimit(stat.System); compareLimits(s, *limits.System, percentage) { - result.System = &s - } - if s := scopeToLimit(stat.Transient); compareLimits(s, *limits.Transient, percentage) { - result.Transient = &s - } - if len(stat.Services) > 0 { - result.Services = make(map[string]notOmitEmptyResourceLimit, len(stat.Services)) - for srv, s := range stat.Services { - ls := limits.Services[srv] - if stat := scopeToLimit(s); compareLimits(stat, ls, percentage) { - result.Services[srv] = stat - } - } - } - if len(stat.Protocols) > 0 { - result.Protocols = make(map[string]notOmitEmptyResourceLimit, len(stat.Protocols)) - for proto, s := range stat.Protocols { - ls := limits.Protocols[string(proto)] - if stat := scopeToLimit(s); compareLimits(stat, ls, percentage) { - result.Protocols[string(proto)] = stat - } - } + } + for _, v := range cfg.ServicePeer { + if v != emptyResourceConfig { + return false } - if len(stat.Peers) > 0 { - result.Peers = make(map[string]notOmitEmptyResourceLimit, len(stat.Peers)) - for p, s := range stat.Peers { - ls := limits.Peers[p.Pretty()] - if stat := scopeToLimit(s); compareLimits(stat, ls, percentage) { - result.Peers[p.Pretty()] = stat - } - } + } + for _, v := range cfg.Protocol { + if v != emptyResourceConfig { + return false } - - return result, nil - - case scope == config.ResourceMgrSystemScope: - err = mgr.ViewSystem(func(s network.ResourceScope) error { - stat := scopeToLimit(s.Stat()) - result.System = &stat - return nil - }) - return result, err - - case scope == config.ResourceMgrTransientScope: - err = mgr.ViewTransient(func(s network.ResourceScope) error { - stat := scopeToLimit(s.Stat()) - result.Transient = &stat - return nil - }) - return result, err - - case strings.HasPrefix(scope, config.ResourceMgrServiceScopePrefix): - svc := strings.TrimPrefix(scope, config.ResourceMgrServiceScopePrefix) - err = mgr.ViewService(svc, func(s network.ServiceScope) error { - result.Services = map[string]notOmitEmptyResourceLimit{ - svc: scopeToLimit(s.Stat()), - } - return nil - }) - return result, err - - case strings.HasPrefix(scope, config.ResourceMgrProtocolScopePrefix): - proto := strings.TrimPrefix(scope, config.ResourceMgrProtocolScopePrefix) - err = mgr.ViewProtocol(protocol.ID(proto), func(s network.ProtocolScope) error { - result.Protocols = map[string]notOmitEmptyResourceLimit{ - proto: scopeToLimit(s.Stat()), - } - return nil - }) - return result, err - - case strings.HasPrefix(scope, config.ResourceMgrPeerScopePrefix): - p := strings.TrimPrefix(scope, config.ResourceMgrPeerScopePrefix) - pid, err := peer.Decode(p) - if err != nil { - return result, fmt.Errorf("invalid peer ID: %q: %w", p, err) + } + for _, v := range cfg.ProtocolPeer { + if v != emptyResourceConfig { + return false } - err = mgr.ViewPeer(pid, func(s network.PeerScope) error { - result.Peers = map[string]notOmitEmptyResourceLimit{ - p: scopeToLimit(s.Stat()), - } - return nil - }) - return result, err - - default: - return result, fmt.Errorf("invalid scope %q", scope) } -} - -var scopes = []string{ - config.ResourceMgrSystemScope, - config.ResourceMgrTransientScope, - config.ResourceMgrServiceScopePrefix, - config.ResourceMgrProtocolScopePrefix, - config.ResourceMgrPeerScopePrefix, -} - -func scopeToLimit(s network.ScopeStat) notOmitEmptyResourceLimit { - return notOmitEmptyResourceLimit{ - Streams: rcmgr.LimitVal(s.NumStreamsInbound + s.NumStreamsOutbound), - StreamsInbound: rcmgr.LimitVal(s.NumStreamsInbound), - StreamsOutbound: rcmgr.LimitVal(s.NumStreamsOutbound), - Conns: rcmgr.LimitVal(s.NumConnsInbound + s.NumConnsOutbound), - ConnsInbound: rcmgr.LimitVal(s.NumConnsInbound), - ConnsOutbound: rcmgr.LimitVal(s.NumConnsOutbound), - FD: rcmgr.LimitVal(s.NumFD), - Memory: rcmgr.LimitVal64(s.Memory), + for _, v := range cfg.Peer { + if v != emptyResourceConfig { + return false + } } + return true } -// compareLimits compares stat and limit. -// If any of the stats value are equals or above the specified percentage, -// it returns true. -func compareLimits(stat, limit notOmitEmptyResourceLimit, percentage int) bool { - if abovePercentage(int(stat.Memory), int(limit.Memory), percentage) { - return true - } - if abovePercentage(stat.ConnsInbound, limit.ConnsInbound, percentage) { - return true - } - if abovePercentage(stat.ConnsOutbound, limit.ConnsOutbound, percentage) { - return true - } - if abovePercentage(stat.Conns, limit.Conns, percentage) { - return true - } - if abovePercentage(stat.FD, limit.FD, percentage) { - return true - } - if abovePercentage(stat.StreamsInbound, limit.StreamsInbound, percentage) { - return true - } - if abovePercentage(stat.StreamsOutbound, limit.StreamsOutbound, percentage) { - return true - } - if abovePercentage(stat.Streams, limit.Streams, percentage) { - return true +// LimitConfig returns the union of the Computed Default Limits and the User Supplied Override Limits. +func LimitConfig(cfg config.SwarmConfig, userResourceOverrides rcmgr.PartialLimitConfig) (limitConfig rcmgr.ConcreteLimitConfig, logMessageForStartup string, err error) { + limitConfig, msg, err := createDefaultLimitConfig(cfg) + if err != nil { + return rcmgr.ConcreteLimitConfig{}, msg, err } - return false -} - -func abovePercentage[T constraints.Integer | constraints.Float](v1, v2 T, percentage int) bool { - if percentage == 0 { - return true - } + // The logic for defaults and overriding with specified userResourceOverrides + // is documented in docs/libp2p-resource-management.md. + // Any changes here should be reflected there. - if v2 == 0 { - return false - } + // This effectively overrides the computed default LimitConfig with any non-"useDefault" values from the userResourceOverrides file. + // Because of how how Build works, any rcmgr.Default value in userResourceOverrides + // will be overriden with a computed default value. + limitConfig = userResourceOverrides.Build(limitConfig) - return int((float64(v1)/float64(v2))*100) >= percentage + return limitConfig, msg, nil } -func NetLimitAll(mgr network.ResourceManager) (*NetStatOut, error) { - var result = &NetStatOut{} - lister, ok := mgr.(rcmgr.ResourceManagerState) - if !ok { // NullResourceManager - return result, ErrNoResourceMgr - } +type ResourceLimitsAndUsage struct { + // This is duplicated from rcmgr.ResourceResourceLimits but adding *Usage fields. + Memory rcmgr.LimitVal64 + MemoryUsage int64 + FD rcmgr.LimitVal + FDUsage int + Conns rcmgr.LimitVal + ConnsUsage int + ConnsInbound rcmgr.LimitVal + ConnsInboundUsage int + ConnsOutbound rcmgr.LimitVal + ConnsOutboundUsage int + Streams rcmgr.LimitVal + StreamsUsage int + StreamsInbound rcmgr.LimitVal + StreamsInboundUsage int + StreamsOutbound rcmgr.LimitVal + StreamsOutboundUsage int +} - for _, s := range scopes { - switch s { - case config.ResourceMgrSystemScope: - s, err := NetLimit(mgr, config.ResourceMgrSystemScope) - if err != nil { - return nil, err - } - result.System = &s - case config.ResourceMgrTransientScope: - s, err := NetLimit(mgr, config.ResourceMgrSystemScope) - if err != nil { - return nil, err - } - result.Transient = &s - case config.ResourceMgrServiceScopePrefix: - result.Services = make(map[string]notOmitEmptyResourceLimit) - for _, serv := range lister.ListServices() { - s, err := NetLimit(mgr, config.ResourceMgrServiceScopePrefix+serv) - if err != nil { - return nil, err - } - result.Services[serv] = s - } - case config.ResourceMgrProtocolScopePrefix: - result.Protocols = make(map[string]notOmitEmptyResourceLimit) - for _, prot := range lister.ListProtocols() { - ps := string(prot) - s, err := NetLimit(mgr, config.ResourceMgrProtocolScopePrefix+ps) - if err != nil { - return nil, err - } - result.Protocols[ps] = s - } - case config.ResourceMgrPeerScopePrefix: - result.Peers = make(map[string]notOmitEmptyResourceLimit) - for _, peer := range lister.ListPeers() { - ps := peer.Pretty() - s, err := NetLimit(mgr, config.ResourceMgrPeerScopePrefix+ps) - if err != nil { - return nil, err - } - result.Peers[ps] = s - } - } +func (u ResourceLimitsAndUsage) ToResourceLimits() rcmgr.ResourceLimits { + return rcmgr.ResourceLimits{ + Memory: u.Memory, + FD: u.FD, + Conns: u.Conns, + ConnsInbound: u.ConnsInbound, + ConnsOutbound: u.ConnsOutbound, + Streams: u.Streams, + StreamsInbound: u.StreamsInbound, + StreamsOutbound: u.StreamsOutbound, } +} - return result, nil +type LimitsConfigAndUsage struct { + // This is duplicated from rcmgr.ResourceManagerStat but using ResourceLimitsAndUsage + // instead of network.ScopeStat. + System ResourceLimitsAndUsage `json:",omitempty"` + Transient ResourceLimitsAndUsage `json:",omitempty"` + Services map[string]ResourceLimitsAndUsage `json:",omitempty"` + Protocols map[protocol.ID]ResourceLimitsAndUsage `json:",omitempty"` + Peers map[peer.ID]ResourceLimitsAndUsage `json:",omitempty"` } -func NetLimit(mgr network.ResourceManager, scope string) (notOmitEmptyResourceLimit, error) { - var result rcmgr.ResourceLimits - getLimit := func(s network.ResourceScope) error { - limiter, ok := s.(rcmgr.ResourceScopeLimiter) - if !ok { // NullResourceManager - return ErrNoResourceMgr - } +func (u LimitsConfigAndUsage) MarshalJSON() ([]byte, error) { + // we want to marshal the encoded peer id + encodedPeerMap := make(map[string]ResourceLimitsAndUsage, len(u.Peers)) + for p, v := range u.Peers { + encodedPeerMap[p.String()] = v + } + + type Alias LimitsConfigAndUsage + return json.Marshal(&struct { + *Alias + Peers map[string]ResourceLimitsAndUsage `json:",omitempty"` + }{ + Alias: (*Alias)(&u), + Peers: encodedPeerMap, + }) +} - switch limit := limiter.Limit(); l := limit.(type) { - case *rcmgr.BaseLimit: - result = l.ToResourceLimits() - case rcmgr.BaseLimit: - result = l.ToResourceLimits() - default: - return fmt.Errorf("unknown limit type %T", limit) - } +func (u LimitsConfigAndUsage) ToPartialLimitConfig() (result rcmgr.PartialLimitConfig) { + result.System = u.System.ToResourceLimits() + result.Transient = u.Transient.ToResourceLimits() - return nil + result.Service = make(map[string]rcmgr.ResourceLimits, len(u.Services)) + for s, l := range u.Services { + result.Service[s] = l.ToResourceLimits() } - - var err error - switch { - case scope == config.ResourceMgrSystemScope: - err = mgr.ViewSystem(func(s network.ResourceScope) error { return getLimit(s) }) - case scope == config.ResourceMgrTransientScope: - err = mgr.ViewTransient(func(s network.ResourceScope) error { return getLimit(s) }) - case strings.HasPrefix(scope, config.ResourceMgrServiceScopePrefix): - svc := strings.TrimPrefix(scope, config.ResourceMgrServiceScopePrefix) - err = mgr.ViewService(svc, func(s network.ServiceScope) error { return getLimit(s) }) - case strings.HasPrefix(scope, config.ResourceMgrProtocolScopePrefix): - proto := strings.TrimPrefix(scope, config.ResourceMgrProtocolScopePrefix) - err = mgr.ViewProtocol(protocol.ID(proto), func(s network.ProtocolScope) error { return getLimit(s) }) - case strings.HasPrefix(scope, config.ResourceMgrPeerScopePrefix): - p := strings.TrimPrefix(scope, config.ResourceMgrPeerScopePrefix) - var pid peer.ID - pid, err = peer.Decode(p) - if err != nil { - return notOmitEmptyResourceLimit{}, fmt.Errorf("invalid peer ID: %q: %w", p, err) - } - err = mgr.ViewPeer(pid, func(s network.PeerScope) error { return getLimit(s) }) - default: - err = fmt.Errorf("invalid scope %q", scope) + result.Protocol = make(map[protocol.ID]rcmgr.ResourceLimits, len(u.Protocols)) + for p, l := range u.Protocols { + result.Protocol[p] = l.ToResourceLimits() + } + result.Peer = make(map[peer.ID]rcmgr.ResourceLimits, len(u.Peers)) + for p, l := range u.Peers { + result.Peer[p] = l.ToResourceLimits() } - return resourceLimitsToNotOmitEmpty(result), err -} -// NetSetLimit sets new ResourceManager limits for the given scope. The limits take effect immediately, and are also persisted to the repo config. -func NetSetLimit(mgr network.ResourceManager, repo repo.Repo, scope string, limit rcmgr.ResourceLimits) error { - setLimit := func(s network.ResourceScope) error { - limiter, ok := s.(rcmgr.ResourceScopeLimiter) - if !ok { // NullResourceManager - return ErrNoResourceMgr - } + return +} - l := rcmgr.InfiniteLimits.ToPartialLimitConfig().System - limiter.SetLimit(limit.Build(l.Build(rcmgr.BaseLimit{}))) - return nil - } +func MergeLimitsAndStatsIntoLimitsConfigAndUsage(l rcmgr.ConcreteLimitConfig, stats rcmgr.ResourceManagerStat) LimitsConfigAndUsage { + limits := l.ToPartialLimitConfig() - cfg, err := repo.Config() - if err != nil { - return fmt.Errorf("reading config to set limit: %w", err) + return LimitsConfigAndUsage{ + System: mergeResourceLimitsAndScopeStatToResourceLimitsAndUsage(limits.System, stats.System), + Transient: mergeResourceLimitsAndScopeStatToResourceLimitsAndUsage(limits.Transient, stats.Transient), + Services: mergeLimitsAndStatsMapIntoLimitsConfigAndUsageMap(limits.Service, stats.Services), + Protocols: mergeLimitsAndStatsMapIntoLimitsConfigAndUsageMap(limits.Protocol, stats.Protocols), + Peers: mergeLimitsAndStatsMapIntoLimitsConfigAndUsageMap(limits.Peer, stats.Peers), } +} - if cfg.Swarm.ResourceMgr.Limits == nil { - cfg.Swarm.ResourceMgr.Limits = &rcmgr.PartialLimitConfig{} - } - configLimits := cfg.Swarm.ResourceMgr.Limits - - var setConfigFunc func() - switch { - case scope == config.ResourceMgrSystemScope: - err = mgr.ViewSystem(func(s network.ResourceScope) error { return setLimit(s) }) - setConfigFunc = func() { configLimits.System = limit } - case scope == config.ResourceMgrTransientScope: - err = mgr.ViewTransient(func(s network.ResourceScope) error { return setLimit(s) }) - setConfigFunc = func() { configLimits.Transient = limit } - case strings.HasPrefix(scope, config.ResourceMgrServiceScopePrefix): - svc := strings.TrimPrefix(scope, config.ResourceMgrServiceScopePrefix) - err = mgr.ViewService(svc, func(s network.ServiceScope) error { return setLimit(s) }) - setConfigFunc = func() { - if configLimits.Service == nil { - configLimits.Service = map[string]rcmgr.ResourceLimits{} - } - configLimits.Service[svc] = limit - } - case strings.HasPrefix(scope, config.ResourceMgrProtocolScopePrefix): - proto := strings.TrimPrefix(scope, config.ResourceMgrProtocolScopePrefix) - err = mgr.ViewProtocol(protocol.ID(proto), func(s network.ProtocolScope) error { return setLimit(s) }) - setConfigFunc = func() { - if configLimits.Protocol == nil { - configLimits.Protocol = map[protocol.ID]rcmgr.ResourceLimits{} - } - configLimits.Protocol[protocol.ID(proto)] = limit - } - case strings.HasPrefix(scope, config.ResourceMgrPeerScopePrefix): - p := strings.TrimPrefix(scope, config.ResourceMgrPeerScopePrefix) - var pid peer.ID - pid, err = peer.Decode(p) - if err != nil { - return fmt.Errorf("invalid peer ID: %q: %w", p, err) - } - err = mgr.ViewPeer(pid, func(s network.PeerScope) error { return setLimit(s) }) - setConfigFunc = func() { - if configLimits.Peer == nil { - configLimits.Peer = map[peer.ID]rcmgr.ResourceLimits{} +func mergeLimitsAndStatsMapIntoLimitsConfigAndUsageMap[K comparable](limits map[K]rcmgr.ResourceLimits, stats map[K]network.ScopeStat) map[K]ResourceLimitsAndUsage { + r := make(map[K]ResourceLimitsAndUsage, maxInt(len(limits), len(stats))) + for p, s := range stats { + var l rcmgr.ResourceLimits + if limits != nil { + if rl, ok := limits[p]; ok { + l = rl } - configLimits.Peer[pid] = limit } - default: - return fmt.Errorf("invalid scope %q", scope) + r[p] = mergeResourceLimitsAndScopeStatToResourceLimitsAndUsage(l, s) } + for p, s := range limits { + if _, ok := stats[p]; ok { + continue // we already processed this element in the loop above + } - if err != nil { - return fmt.Errorf("setting new limits on resource manager: %w", err) + r[p] = mergeResourceLimitsAndScopeStatToResourceLimitsAndUsage(s, network.ScopeStat{}) } + return r +} - if cfg.Swarm.ResourceMgr.Limits == nil { - cfg.Swarm.ResourceMgr.Limits = &rcmgr.PartialLimitConfig{} +func maxInt(x, y int) int { + if x > y { + return x } - setConfigFunc() + return y +} - if err := repo.SetConfig(cfg); err != nil { - return fmt.Errorf("writing new limits to repo config: %w", err) +func mergeResourceLimitsAndScopeStatToResourceLimitsAndUsage(rl rcmgr.ResourceLimits, ss network.ScopeStat) ResourceLimitsAndUsage { + return ResourceLimitsAndUsage{ + Memory: rl.Memory, + MemoryUsage: ss.Memory, + FD: rl.FD, + FDUsage: ss.NumFD, + Conns: rl.Conns, + ConnsUsage: ss.NumConnsOutbound + ss.NumConnsInbound, + ConnsOutbound: rl.ConnsOutbound, + ConnsOutboundUsage: ss.NumConnsOutbound, + ConnsInbound: rl.ConnsInbound, + ConnsInboundUsage: ss.NumConnsInbound, + Streams: rl.Streams, + StreamsUsage: ss.NumStreamsOutbound + ss.NumConnsInbound, + StreamsOutbound: rl.StreamsOutbound, + StreamsOutboundUsage: ss.NumConnsOutbound, + StreamsInbound: rl.StreamsInbound, + StreamsInboundUsage: ss.NumConnsInbound, } +} - return nil +type ResourceInfos []ResourceInfo + +type ResourceInfo struct { + ScopeName string + LimitName string + LimitValue rcmgr.LimitVal64 + CurrentUsage int64 } -// NetResetLimit resets ResourceManager limits to defaults. The limits take effect immediately, and are also persisted to the repo config. -func NetResetLimit(mgr network.ResourceManager, repo repo.Repo, scope string) (rcmgr.BaseLimit, error) { - var result rcmgr.BaseLimit +// LimitConfigsToInfo gets limits and stats and generates a list of scopes and limits to be printed. +func LimitConfigsToInfo(stats LimitsConfigAndUsage) ResourceInfos { + result := ResourceInfos{} - setLimit := func(s network.ResourceScope, l rcmgr.Limit) error { - limiter, ok := s.(rcmgr.ResourceScopeLimiter) - if !ok { - return ErrNoResourceMgr - } + result = append(result, resourceLimitsAndUsageToResourceInfo(config.ResourceMgrSystemScope, stats.System)...) + result = append(result, resourceLimitsAndUsageToResourceInfo(config.ResourceMgrTransientScope, stats.Transient)...) - limiter.SetLimit(l) - return nil + for i, s := range stats.Services { + result = append(result, resourceLimitsAndUsageToResourceInfo( + config.ResourceMgrServiceScopePrefix+i, + s, + )...) } - cfg, err := repo.Config() - if err != nil { - return rcmgr.BaseLimit{}, fmt.Errorf("reading config to reset limit: %w", err) + for i, p := range stats.Protocols { + result = append(result, resourceLimitsAndUsageToResourceInfo( + config.ResourceMgrProtocolScopePrefix+string(i), + p, + )...) } - defaultsOrig, err := createDefaultLimitConfig(cfg.Swarm) - if err != nil { - return rcmgr.BaseLimit{}, fmt.Errorf("creating default limit config: %w", err) + for i, p := range stats.Peers { + result = append(result, resourceLimitsAndUsageToResourceInfo( + config.ResourceMgrPeerScopePrefix+i.Pretty(), + p, + )...) } - defaults := defaultsOrig.ToPartialLimitConfig() - // INVESTIGATE(@Jorropo): Why do we save scaled configs in the repo ? + return result +} - if cfg.Swarm.ResourceMgr.Limits == nil { - cfg.Swarm.ResourceMgr.Limits = &rcmgr.PartialLimitConfig{} - } - configLimits := cfg.Swarm.ResourceMgr.Limits - - var setConfigFunc func() rcmgr.BaseLimit - switch { - case scope == config.ResourceMgrSystemScope: - err = mgr.ViewSystem(func(s network.ResourceScope) error { return setLimit(s, defaults.System.Build(rcmgr.BaseLimit{})) }) - setConfigFunc = func() rcmgr.BaseLimit { - configLimits.System = defaults.System - return defaults.System.Build(rcmgr.BaseLimit{}) - } - case scope == config.ResourceMgrTransientScope: - err = mgr.ViewTransient(func(s network.ResourceScope) error { return setLimit(s, defaults.Transient.Build(rcmgr.BaseLimit{})) }) - setConfigFunc = func() rcmgr.BaseLimit { - configLimits.Transient = defaults.Transient - return defaults.Transient.Build(rcmgr.BaseLimit{}) - } - case strings.HasPrefix(scope, config.ResourceMgrServiceScopePrefix): - svc := strings.TrimPrefix(scope, config.ResourceMgrServiceScopePrefix) - - err = mgr.ViewService(svc, func(s network.ServiceScope) error { - return setLimit(s, defaults.ServiceDefault.Build(rcmgr.BaseLimit{})) - }) - setConfigFunc = func() rcmgr.BaseLimit { - if configLimits.Service == nil { - configLimits.Service = map[string]rcmgr.ResourceLimits{} - } - configLimits.Service[svc] = defaults.ServiceDefault - return defaults.ServiceDefault.Build(rcmgr.BaseLimit{}) - } - case strings.HasPrefix(scope, config.ResourceMgrProtocolScopePrefix): - proto := strings.TrimPrefix(scope, config.ResourceMgrProtocolScopePrefix) - - err = mgr.ViewProtocol(protocol.ID(proto), func(s network.ProtocolScope) error { - return setLimit(s, defaults.ProtocolDefault.Build(rcmgr.BaseLimit{})) - }) - setConfigFunc = func() rcmgr.BaseLimit { - if configLimits.Protocol == nil { - configLimits.Protocol = map[protocol.ID]rcmgr.ResourceLimits{} - } - configLimits.Protocol[protocol.ID(proto)] = defaults.ProtocolDefault +const ( + limitNameMemory = "Memory" + limitNameFD = "FD" + limitNameConns = "Conns" + limitNameConnsInbound = "ConnsInbound" + limitNameConnsOutbound = "ConnsOutbound" + limitNameStreams = "Streams" + limitNameStreamsInbound = "StreamsInbound" + limitNameStreamsOutbound = "StreamsOutbound" +) - return defaults.ProtocolDefault.Build(rcmgr.BaseLimit{}) - } - case strings.HasPrefix(scope, config.ResourceMgrPeerScopePrefix): - p := strings.TrimPrefix(scope, config.ResourceMgrPeerScopePrefix) +var limits = []string{ + limitNameMemory, + limitNameFD, + limitNameConns, + limitNameConnsInbound, + limitNameConnsOutbound, + limitNameStreams, + limitNameStreamsInbound, + limitNameStreamsOutbound, +} - var pid peer.ID - pid, err = peer.Decode(p) - if err != nil { - return result, fmt.Errorf("invalid peer ID: %q: %w", p, err) +func resourceLimitsAndUsageToResourceInfo(scopeName string, stats ResourceLimitsAndUsage) ResourceInfos { + result := ResourceInfos{} + for _, l := range limits { + ri := ResourceInfo{ + ScopeName: scopeName, } - - err = mgr.ViewPeer(pid, func(s network.PeerScope) error { return setLimit(s, defaults.PeerDefault.Build(rcmgr.BaseLimit{})) }) - setConfigFunc = func() rcmgr.BaseLimit { - if configLimits.Peer == nil { - configLimits.Peer = map[peer.ID]rcmgr.ResourceLimits{} - } - configLimits.Peer[pid] = defaults.PeerDefault - - return defaults.PeerDefault.Build(rcmgr.BaseLimit{}) + switch l { + case limitNameMemory: + ri.LimitName = limitNameMemory + ri.LimitValue = stats.Memory + ri.CurrentUsage = stats.MemoryUsage + case limitNameFD: + ri.LimitName = limitNameFD + ri.LimitValue = rcmgr.LimitVal64(stats.FD) + ri.CurrentUsage = int64(stats.FDUsage) + case limitNameConns: + ri.LimitName = limitNameConns + ri.LimitValue = rcmgr.LimitVal64(stats.Conns) + ri.CurrentUsage = int64(stats.ConnsUsage) + case limitNameConnsInbound: + ri.LimitName = limitNameConnsInbound + ri.LimitValue = rcmgr.LimitVal64(stats.ConnsInbound) + ri.CurrentUsage = int64(stats.ConnsInboundUsage) + case limitNameConnsOutbound: + ri.LimitName = limitNameConnsOutbound + ri.LimitValue = rcmgr.LimitVal64(stats.ConnsOutbound) + ri.CurrentUsage = int64(stats.ConnsOutboundUsage) + case limitNameStreams: + ri.LimitName = limitNameStreams + ri.LimitValue = rcmgr.LimitVal64(stats.Streams) + ri.CurrentUsage = int64(stats.StreamsUsage) + case limitNameStreamsInbound: + ri.LimitName = limitNameStreamsInbound + ri.LimitValue = rcmgr.LimitVal64(stats.StreamsInbound) + ri.CurrentUsage = int64(stats.StreamsInboundUsage) + case limitNameStreamsOutbound: + ri.LimitName = limitNameStreamsOutbound + ri.LimitValue = rcmgr.LimitVal64(stats.StreamsOutbound) + ri.CurrentUsage = int64(stats.StreamsOutboundUsage) } - default: - return result, fmt.Errorf("invalid scope %q", scope) - } - - if err != nil { - return result, fmt.Errorf("resetting new limits on resource manager: %w", err) - } - result = setConfigFunc() + if ri.LimitValue == rcmgr.Unlimited64 || ri.LimitValue == rcmgr.DefaultLimit64 { + // ignore unlimited and unset limits to remove noise from output. + continue + } - if err := repo.SetConfig(cfg); err != nil { - return result, fmt.Errorf("writing new limits to repo config: %w", err) + result = append(result, ri) } - return result, nil + return result } -func ensureConnMgrMakeSenseVsResourceMgr(orig rcmgr.ConcreteLimitConfig, cmgr config.ConnMgr) error { - if cmgr.Type.WithDefault(config.DefaultConnMgrType) == "none" { - return nil // none connmgr, no checks to do +func ensureConnMgrMakeSenseVsResourceMgr(concreteLimits rcmgr.ConcreteLimitConfig, cfg config.SwarmConfig) error { + if cfg.ConnMgr.Type.WithDefault(config.DefaultConnMgrType) == "none" || len(cfg.ResourceMgr.Allowlist) != 0 { + // no connmgr OR + // If an allowlist is set, a user may be enacting some form of DoS defense. + // We don't want want to modify the System.ConnsInbound in that case for example + // as it may make sense for it to be (and stay) as "blockAll" + // so that only connections within the allowlist of multiaddrs get established. + return nil } - rcm := orig.ToPartialLimitConfig() + rcm := concreteLimits.ToPartialLimitConfig() - highWater := cmgr.HighWater.WithDefault(config.DefaultConnMgrHighWater) - if rcm.System.ConnsInbound <= rcm.System.Conns { - if int64(rcm.System.ConnsInbound) <= highWater { - // nolint - return fmt.Errorf(` -Unable to initialize libp2p due to conflicting limit configuration: -ResourceMgr.Limits.System.ConnsInbound (%d) must be bigger than ConnMgr.HighWater (%d) -`, rcm.System.ConnsInbound, highWater) - } - } else if int64(rcm.System.Conns) <= highWater { + highWater := cfg.ConnMgr.HighWater.WithDefault(config.DefaultConnMgrHighWater) + if rcm.System.Conns != rcmgr.Unlimited && int64(rcm.System.Conns) <= highWater { // nolint return fmt.Errorf(` -Unable to initialize libp2p due to conflicting limit configuration: -ResourceMgr.Limits.System.Conns (%d) must be bigger than ConnMgr.HighWater (%d) +Unable to initialize libp2p due to conflicting resource manager limit configuration. +resource manager System.Conns (%d) must be bigger than ConnMgr.HighWater (%d) `, rcm.System.Conns, highWater) } - if rcm.System.StreamsInbound <= rcm.System.Streams { - if int64(rcm.System.StreamsInbound) <= highWater { - // nolint - return fmt.Errorf(` -Unable to initialize libp2p due to conflicting limit configuration: -ResourceMgr.Limits.System.StreamsInbound (%d) must be bigger than ConnMgr.HighWater (%d) -`, rcm.System.StreamsInbound, highWater) - } - } else if int64(rcm.System.Streams) <= highWater { + if rcm.System.ConnsInbound != rcmgr.Unlimited && int64(rcm.System.ConnsInbound) <= highWater { // nolint return fmt.Errorf(` -Unable to initialize libp2p due to conflicting limit configuration: -ResourceMgr.Limits.System.Streams (%d) must be bigger than ConnMgr.HighWater (%d) +Unable to initialize libp2p due to conflicting resource manager limit configuration. +resource manager System.ConnsInbound (%d) must be bigger than ConnMgr.HighWater (%d) +`, rcm.System.ConnsInbound, highWater) + } + if rcm.System.Streams != rcmgr.Unlimited && int64(rcm.System.Streams) <= highWater { + // nolint + return fmt.Errorf(` +Unable to initialize libp2p due to conflicting resource manager limit configuration. +resource manager System.Streams (%d) must be bigger than ConnMgr.HighWater (%d) `, rcm.System.Streams, highWater) + } + if rcm.System.StreamsInbound != rcmgr.Unlimited && int64(rcm.System.StreamsInbound) <= highWater { + // nolint + return fmt.Errorf(` +Unable to initialize libp2p due to conflicting resource manager limit configuration. +resource manager System.StreamsInbound (%d) must be bigger than ConnMgr.HighWater (%d) +`, rcm.System.StreamsInbound, highWater) } return nil } diff --git a/core/node/libp2p/rcmgr_defaults.go b/core/node/libp2p/rcmgr_defaults.go index 05dda7745a8..5faaf7979b3 100644 --- a/core/node/libp2p/rcmgr_defaults.go +++ b/core/node/libp2p/rcmgr_defaults.go @@ -4,70 +4,31 @@ import ( "fmt" "github.com/dustin/go-humanize" + "github.com/ipfs/kubo/config" + "github.com/ipfs/kubo/core/node/libp2p/fd" "github.com/libp2p/go-libp2p" rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" "github.com/pbnjay/memory" - - "github.com/ipfs/kubo/config" - "github.com/ipfs/kubo/core/node/libp2p/fd" ) -// We are doing some magic when parsing config files (we are using a map[string]interface{} to compare config files). -// When you don't have a type the JSON Parse function cast numbers to float64 by default, -// losing precision when writing the final number. So if we use math.MaxInt as our infinite number, -// after writing the config file we will have 9223372036854776000 instead of 9223372036854775807, -// making the parsing process fail. Setting 1e9 (1000000000) as "no limit" value. It also avoids to overflow on 32 bit architectures. -const bigEnough = 1e9 - -var infiniteBaseLimit = rcmgr.BaseLimit{ - Streams: bigEnough, - StreamsInbound: bigEnough, - StreamsOutbound: bigEnough, - Conns: bigEnough, - ConnsInbound: bigEnough, - ConnsOutbound: bigEnough, - FD: bigEnough, - Memory: bigEnough, -} - -var noLimitIncrease = rcmgr.BaseLimitIncrease{ - ConnsInbound: 0, - ConnsOutbound: 0, - Conns: 0, - StreamsInbound: 0, - StreamsOutbound: 0, - Streams: 0, - Memory: 0, - FDFraction: 0, -} +var infiniteResourceLimits = rcmgr.InfiniteLimits.ToPartialLimitConfig().System // This file defines implicit limit defaults used when Swarm.ResourceMgr.Enabled // createDefaultLimitConfig creates LimitConfig to pass to libp2p's resource manager. // The defaults follow the documentation in docs/libp2p-resource-management.md. // Any changes in the logic here should be reflected there. -func createDefaultLimitConfig(cfg config.SwarmConfig) (rcmgr.ConcreteLimitConfig, error) { +func createDefaultLimitConfig(cfg config.SwarmConfig) (limitConfig rcmgr.ConcreteLimitConfig, logMessageForStartup string, err error) { maxMemoryDefaultString := humanize.Bytes(uint64(memory.TotalMemory()) / 2) maxMemoryString := cfg.ResourceMgr.MaxMemory.WithDefault(maxMemoryDefaultString) maxMemory, err := humanize.ParseBytes(maxMemoryString) if err != nil { - return rcmgr.ConcreteLimitConfig{}, err + return rcmgr.ConcreteLimitConfig{}, "", err } maxMemoryMB := maxMemory / (1024 * 1024) maxFD := int(cfg.ResourceMgr.MaxFileDescriptors.WithDefault(int64(fd.GetNumFDs()) / 2)) - // We want to see this message on startup, that's why we are using fmt instead of log. - fmt.Printf(` -Computing default go-libp2p Resource Manager limits based on: - - 'Swarm.ResourceMgr.MaxMemory': %q - - 'Swarm.ResourceMgr.MaxFileDescriptors': %d - -Applying any user-supplied overrides on top. -Run 'ipfs swarm limit all' to see the resulting limits. - -`, maxMemoryString, maxFD) - // At least as of 2023-01-25, it's possible to open a connection that // doesn't ask for any memory usage with the libp2p Resource Manager/Accountant // (see https://github.com/libp2p/go-libp2p/issues/2010#issuecomment-1404280736). @@ -79,109 +40,86 @@ Run 'ipfs swarm limit all' to see the resulting limits. // (see https://github.com/libp2p/go-libp2p/blob/master/p2p/host/resource-manager/limit_defaults.go#L357 ). systemConnsInbound := int(1 * maxMemoryMB) - scalingLimitConfig := rcmgr.ScalingLimitConfig{ - SystemBaseLimit: rcmgr.BaseLimit{ - Memory: int64(maxMemory), - FD: maxFD, + partialLimits := rcmgr.PartialLimitConfig{ + System: rcmgr.ResourceLimits{ + Memory: rcmgr.LimitVal64(maxMemory), + FD: rcmgr.LimitVal(maxFD), - // By default, we just limit connections on the inbound side. - Conns: bigEnough, - ConnsInbound: systemConnsInbound, - ConnsOutbound: bigEnough, + Conns: rcmgr.Unlimited, + ConnsInbound: rcmgr.LimitVal(systemConnsInbound), + ConnsOutbound: rcmgr.Unlimited, - Streams: bigEnough, - StreamsInbound: bigEnough, - StreamsOutbound: bigEnough, + Streams: rcmgr.Unlimited, + StreamsOutbound: rcmgr.Unlimited, + StreamsInbound: rcmgr.Unlimited, }, - SystemLimitIncrease: noLimitIncrease, - // Transient connections won't cause any memory to accounted for by the resource manager. + // Transient connections won't cause any memory to be accounted for by the resource manager/accountant. // Only established connections do. // As a result, we can't rely on System.Memory to protect us from a bunch of transient connection being opened. // We limit the same values as the System scope, but only allow the Transient scope to take 25% of what is allowed for the System scope. - TransientBaseLimit: rcmgr.BaseLimit{ - Memory: int64(maxMemory / 4), - FD: maxFD / 4, + Transient: rcmgr.ResourceLimits{ + Memory: rcmgr.LimitVal64(maxMemory / 4), + FD: rcmgr.LimitVal(maxFD / 4), - Conns: bigEnough, - ConnsInbound: systemConnsInbound / 4, - ConnsOutbound: bigEnough, + Conns: rcmgr.Unlimited, + ConnsInbound: rcmgr.LimitVal(systemConnsInbound / 4), + ConnsOutbound: rcmgr.Unlimited, - Streams: bigEnough, - StreamsInbound: bigEnough, - StreamsOutbound: bigEnough, + Streams: rcmgr.Unlimited, + StreamsInbound: rcmgr.Unlimited, + StreamsOutbound: rcmgr.Unlimited, }, - TransientLimitIncrease: noLimitIncrease, - // Lets get out of the way of the allow list functionality. // If someone specified "Swarm.ResourceMgr.Allowlist" we should let it go through. - AllowlistedSystemBaseLimit: infiniteBaseLimit, - AllowlistedSystemLimitIncrease: noLimitIncrease, + AllowlistedSystem: infiniteResourceLimits, - AllowlistedTransientBaseLimit: infiniteBaseLimit, - AllowlistedTransientLimitIncrease: noLimitIncrease, + AllowlistedTransient: infiniteResourceLimits, // Keep it simple by not having Service, ServicePeer, Protocol, ProtocolPeer, Conn, or Stream limits. - ServiceBaseLimit: infiniteBaseLimit, - ServiceLimitIncrease: noLimitIncrease, + ServiceDefault: infiniteResourceLimits, - ServicePeerBaseLimit: infiniteBaseLimit, - ServicePeerLimitIncrease: noLimitIncrease, + ServicePeerDefault: infiniteResourceLimits, - ProtocolBaseLimit: infiniteBaseLimit, - ProtocolLimitIncrease: noLimitIncrease, + ProtocolDefault: infiniteResourceLimits, - ProtocolPeerBaseLimit: infiniteBaseLimit, - ProtocolPeerLimitIncrease: noLimitIncrease, + ProtocolPeerDefault: infiniteResourceLimits, - ConnBaseLimit: infiniteBaseLimit, - ConnLimitIncrease: noLimitIncrease, + Conn: infiniteResourceLimits, - StreamBaseLimit: infiniteBaseLimit, - StreamLimitIncrease: noLimitIncrease, + Stream: infiniteResourceLimits, // Limit the resources consumed by a peer. // This doesn't protect us against intentional DoS attacks since an attacker can easily spin up multiple peers. // We specify this limit against unintentional DoS attacks (e.g., a peer has a bug and is sending too much traffic intentionally). // In that case we want to keep that peer's resource consumption contained. // To keep this simple, we only constrain inbound connections and streams. - PeerBaseLimit: rcmgr.BaseLimit{ - Memory: bigEnough, - FD: bigEnough, - Conns: bigEnough, - ConnsInbound: rcmgr.DefaultLimits.PeerBaseLimit.ConnsInbound, - ConnsOutbound: bigEnough, - Streams: bigEnough, - StreamsInbound: rcmgr.DefaultLimits.PeerBaseLimit.StreamsInbound, - StreamsOutbound: bigEnough, - }, - // Most limits don't see an increase because they're already infinite/bigEnough. - // The values that should scale based on the amount of memory allocated to libp2p need to increase accordingly. - PeerLimitIncrease: rcmgr.BaseLimitIncrease{ - Memory: 0, - FDFraction: 0, - Conns: 0, - ConnsInbound: rcmgr.DefaultLimits.PeerLimitIncrease.ConnsInbound, - ConnsOutbound: 0, - Streams: 0, - StreamsInbound: rcmgr.DefaultLimits.PeerLimitIncrease.StreamsInbound, - StreamsOutbound: 0, + PeerDefault: rcmgr.ResourceLimits{ + Memory: rcmgr.Unlimited64, + FD: rcmgr.Unlimited, + Conns: rcmgr.Unlimited, + ConnsInbound: rcmgr.DefaultLimit, + ConnsOutbound: rcmgr.Unlimited, + Streams: rcmgr.Unlimited, + StreamsInbound: rcmgr.DefaultLimit, + StreamsOutbound: rcmgr.Unlimited, }, } - // Whatever limits libp2p has specifically tuned for its protocols/services we'll apply. + scalingLimitConfig := rcmgr.DefaultLimits libp2p.SetDefaultServiceLimits(&scalingLimitConfig) - orig := scalingLimitConfig.Scale(int64(maxMemory), maxFD) - defaultLimitConfig := orig.ToPartialLimitConfig() + // Anything set above in partialLimits that had a value of rcmgr.DefaultLimit will be overridden. + // Anything in scalingLimitConfig that wasn't defined in partialLimits above will be added (e.g., libp2p's default service limits). + partialLimits = partialLimits.Build(scalingLimitConfig.Scale(int64(maxMemory), maxFD)).ToPartialLimitConfig() // Simple checks to overide autoscaling ensuring limits make sense versus the connmgr values. // There are ways to break this, but this should catch most problems already. // We might improve this in the future. // See: https://github.com/ipfs/kubo/issues/9545 - if cfg.ConnMgr.Type.WithDefault(config.DefaultConnMgrType) != "none" { - maxInboundConns := int64(defaultLimitConfig.System.ConnsInbound) + if partialLimits.System.ConnsInbound != rcmgr.Unlimited && cfg.ConnMgr.Type.WithDefault(config.DefaultConnMgrType) != "none" { + maxInboundConns := int64(partialLimits.System.ConnsInbound) if connmgrHighWaterTimesTwo := cfg.ConnMgr.HighWater.WithDefault(config.DefaultConnMgrHighWater) * 2; maxInboundConns < connmgrHighWaterTimesTwo { maxInboundConns = connmgrHighWaterTimesTwo } @@ -191,9 +129,19 @@ Run 'ipfs swarm limit all' to see the resulting limits. } // Scale System.StreamsInbound as well, but use the existing ratio of StreamsInbound to ConnsInbound - defaultLimitConfig.System.StreamsInbound = rcmgr.LimitVal(maxInboundConns * int64(defaultLimitConfig.System.StreamsInbound) / int64(defaultLimitConfig.System.ConnsInbound)) - defaultLimitConfig.System.ConnsInbound = rcmgr.LimitVal(maxInboundConns) + partialLimits.System.StreamsInbound = rcmgr.LimitVal(maxInboundConns * int64(partialLimits.System.StreamsInbound) / int64(partialLimits.System.ConnsInbound)) + partialLimits.System.ConnsInbound = rcmgr.LimitVal(maxInboundConns) } - return defaultLimitConfig.Build(orig), nil + msg := fmt.Sprintf(` +Computed default go-libp2p Resource Manager limits based on: + - 'Swarm.ResourceMgr.MaxMemory': %q + - 'Swarm.ResourceMgr.MaxFileDescriptors': %d + +Theses can be inspected with 'ipfs swarm resources'. + +`, maxMemoryString, maxFD) + + // We already have a complete value thus pass in an empty ConcreteLimitConfig. + return partialLimits.Build(rcmgr.ConcreteLimitConfig{}), msg, nil } diff --git a/core/node/libp2p/rcmgr_test.go b/core/node/libp2p/rcmgr_test.go deleted file mode 100644 index e273ff756aa..00000000000 --- a/core/node/libp2p/rcmgr_test.go +++ /dev/null @@ -1,12 +0,0 @@ -package libp2p - -import ( - "testing" - - "github.com/stretchr/testify/require" -) - -func TestPercentage(t *testing.T) { - require.True(t, abovePercentage(10, 100, 10)) - require.True(t, abovePercentage(100, 100, 99)) -} diff --git a/core/node/storage.go b/core/node/storage.go index 2e831fae22e..d109210587d 100644 --- a/core/node/storage.go +++ b/core/node/storage.go @@ -14,7 +14,8 @@ import ( // RepoConfig loads configuration from the repo func RepoConfig(repo repo.Repo) (*config.Config, error) { - return repo.Config() + cfg, err := repo.Config() + return cfg, err } // Datastore provides the datastore diff --git a/go.mod b/go.mod index 2892d37401e..34603ebd2d4 100644 --- a/go.mod +++ b/go.mod @@ -106,7 +106,6 @@ require ( go.uber.org/fx v1.18.2 go.uber.org/zap v1.24.0 golang.org/x/crypto v0.5.0 - golang.org/x/exp v0.0.0-20230129154200-a960b3787bd2 golang.org/x/mod v0.7.0 golang.org/x/sync v0.1.0 golang.org/x/sys v0.5.0 @@ -228,6 +227,7 @@ require ( go.uber.org/atomic v1.10.0 // indirect go.uber.org/multierr v1.9.0 // indirect go4.org v0.0.0-20200411211856-f5505b9728dd // indirect + golang.org/x/exp v0.0.0-20230129154200-a960b3787bd2 // indirect golang.org/x/net v0.7.0 // indirect golang.org/x/oauth2 v0.0.0-20220223155221-ee480838109b // indirect golang.org/x/term v0.5.0 // indirect diff --git a/repo/fsrepo/fsrepo.go b/repo/fsrepo/fsrepo.go index 99104b08318..6a7da9a0694 100644 --- a/repo/fsrepo/fsrepo.go +++ b/repo/fsrepo/fsrepo.go @@ -16,6 +16,7 @@ import ( repo "github.com/ipfs/kubo/repo" "github.com/ipfs/kubo/repo/common" dir "github.com/ipfs/kubo/thirdparty/dir" + rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" ds "github.com/ipfs/go-datastore" measure "github.com/ipfs/go-ds-measure" @@ -102,11 +103,12 @@ type FSRepo struct { configFilePath string // lockfile is the file system lock to prevent others from opening // the same fsrepo path concurrently - lockfile io.Closer - config *config.Config - ds repo.Datastore - keystore keystore.Keystore - filemgr *filestore.FileManager + lockfile io.Closer + config *config.Config + userResourceOverrides rcmgr.PartialLimitConfig + ds repo.Datastore + keystore keystore.Keystore + filemgr *filestore.FileManager } var _ repo.Repo = (*FSRepo)(nil) @@ -180,6 +182,10 @@ func open(repoPath string, userConfigFilePath string) (repo.Repo, error) { return nil, err } + if err := r.openUserResourceOverrides(); err != nil { + return nil, err + } + if err := r.openDatastore(); err != nil { return nil, err } @@ -437,6 +443,17 @@ func (r *FSRepo) openConfig() error { return nil } +// openUserResourceOverrides will remove all overrides if the file is not present. +// It will error if the decoding fails. +func (r *FSRepo) openUserResourceOverrides() error { + // This filepath is documented in docs/libp2p-resource-management.md and be kept in sync. + err := serialize.ReadConfigFile(filepath.Join(r.path, "libp2p-resource-limit-overrides.json"), &r.userResourceOverrides) + if err == serialize.ErrNotInitialized { + err = nil + } + return err +} + func (r *FSRepo) openKeystore() error { ksp := filepath.Join(r.path, "keystore") ks, err := keystore.NewFSKeystore(ksp) @@ -554,6 +571,21 @@ func (r *FSRepo) Config() (*config.Config, error) { return r.config, nil } +func (r *FSRepo) UserResourceOverrides() (rcmgr.PartialLimitConfig, error) { + // It is not necessary to hold the package lock since the repo is in an + // opened state. The package lock is _not_ meant to ensure that the repo is + // thread-safe. The package lock is only meant to guard against removal and + // coordinate the lockfile. However, we provide thread-safety to keep + // things simple. + packageLock.Lock() + defer packageLock.Unlock() + + if r.closed { + return rcmgr.PartialLimitConfig{}, errors.New("cannot access config, repo not open") + } + return r.userResourceOverrides, nil +} + func (r *FSRepo) FileManager() *filestore.FileManager { return r.filemgr } diff --git a/repo/mock.go b/repo/mock.go index a50d448ed02..6f128d2631c 100644 --- a/repo/mock.go +++ b/repo/mock.go @@ -7,6 +7,7 @@ import ( filestore "github.com/ipfs/go-filestore" keystore "github.com/ipfs/go-ipfs-keystore" + rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" config "github.com/ipfs/kubo/config" ma "github.com/multiformats/go-multiaddr" @@ -26,6 +27,10 @@ func (m *Mock) Config() (*config.Config, error) { return &m.C, nil // FIXME threadsafety } +func (m *Mock) UserResourceOverrides() (rcmgr.PartialLimitConfig, error) { + return rcmgr.PartialLimitConfig{}, nil +} + func (m *Mock) SetConfig(updated *config.Config) error { m.C = *updated // FIXME threadsafety return nil diff --git a/repo/repo.go b/repo/repo.go index bec02049d18..6767dda7226 100644 --- a/repo/repo.go +++ b/repo/repo.go @@ -8,6 +8,7 @@ import ( filestore "github.com/ipfs/go-filestore" keystore "github.com/ipfs/go-ipfs-keystore" + rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" ds "github.com/ipfs/go-datastore" config "github.com/ipfs/kubo/config" @@ -24,6 +25,10 @@ type Repo interface { // to the returned config are not automatically persisted. Config() (*config.Config, error) + // UserResourceOverrides returns optional user resource overrides for the + // libp2p resource manager. + UserResourceOverrides() (rcmgr.PartialLimitConfig, error) + // BackupConfig creates a backup of the current configuration file using // the given prefix for naming. BackupConfig(prefix string) (string, error) diff --git a/test/cli/basic_commands_test.go b/test/cli/basic_commands_test.go index 30c1f1f9a9a..220ef285452 100644 --- a/test/cli/basic_commands_test.go +++ b/test/cli/basic_commands_test.go @@ -88,6 +88,7 @@ func TestAllSubcommandsAcceptHelp(t *testing.T) { t.Parallel() node := harness.NewT(t).NewNode() for _, cmd := range node.IPFSCommands() { + cmd := cmd t.Run(fmt.Sprintf("command %q accepts help", cmd), func(t *testing.T) { t.Parallel() splitCmd := strings.Split(cmd, " ")[1:] diff --git a/test/cli/harness/node.go b/test/cli/harness/node.go index e486771cad9..0d0295307ff 100644 --- a/test/cli/harness/node.go +++ b/test/cli/harness/node.go @@ -20,6 +20,7 @@ import ( "github.com/ipfs/kubo/config" serial "github.com/ipfs/kubo/config/serialize" "github.com/libp2p/go-libp2p/core/peer" + rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" "github.com/multiformats/go-multiaddr" manet "github.com/multiformats/go-multiaddr/net" ) @@ -96,6 +97,38 @@ func (n *Node) UpdateConfig(f func(cfg *config.Config)) { n.WriteConfig(cfg) } +func (n *Node) ReadUserResourceOverrides() *rcmgr.PartialLimitConfig { + var r rcmgr.PartialLimitConfig + err := serial.ReadConfigFile(filepath.Join(n.Dir, "libp2p-resource-limit-overrides.json"), &r) + switch err { + case nil, serial.ErrNotInitialized: + return &r + default: + panic(err) + } +} + +func (n *Node) WriteUserSuppliedResourceOverrides(c *rcmgr.PartialLimitConfig) { + err := serial.WriteConfigFile(filepath.Join(n.Dir, "libp2p-resource-limit-overrides.json"), c) + if err != nil { + panic(err) + } +} + +func (n *Node) UpdateUserSuppliedResourceManagerOverrides(f func(overrides *rcmgr.PartialLimitConfig)) { + overrides := n.ReadUserResourceOverrides() + f(overrides) + n.WriteUserSuppliedResourceOverrides(overrides) +} + +func (n *Node) UpdateConfigAndUserSuppliedResourceManagerOverrides(f func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig)) { + overrides := n.ReadUserResourceOverrides() + cfg := n.ReadConfig() + f(cfg, overrides) + n.WriteConfig(cfg) + n.WriteUserSuppliedResourceOverrides(overrides) +} + func (n *Node) IPFS(args ...string) RunResult { res := n.RunIPFS(args...) n.Runner.AssertNoError(res) diff --git a/test/cli/rcmgr_test.go b/test/cli/rcmgr_test.go index 23e123655f7..fb644e1a746 100644 --- a/test/cli/rcmgr_test.go +++ b/test/cli/rcmgr_test.go @@ -7,6 +7,8 @@ import ( "github.com/ipfs/kubo/config" "github.com/ipfs/kubo/core/node/libp2p" "github.com/ipfs/kubo/test/cli/harness" + "github.com/libp2p/go-libp2p/core/peer" + "github.com/libp2p/go-libp2p/core/protocol" rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -24,19 +26,14 @@ func TestRcmgr(t *testing.T) { node.StartDaemon() - t.Run("swarm limit should fail", func(t *testing.T) { - res := node.RunIPFS("swarm", "limit", "system") + t.Run("swarm resources should fail", func(t *testing.T) { + res := node.RunIPFS("swarm", "resources") assert.Equal(t, 1, res.ExitCode()) - assert.Contains(t, res.Stderr.Lines()[0], "missing ResourceMgr") - }) - t.Run("swarm stats should fail", func(t *testing.T) { - res := node.RunIPFS("swarm", "stats", "all") - assert.Equal(t, 1, res.ExitCode()) - assert.Contains(t, res.Stderr.Lines()[0], "missing ResourceMgr") + assert.Contains(t, res.Stderr.String(), "missing ResourceMgr") }) }) - t.Run("Node in offline mode", func(t *testing.T) { + t.Run("Node with resource manager disabled", func(t *testing.T) { t.Parallel() node := harness.NewT(t).NewNode().Init() node.UpdateConfig(func(cfg *config.Config) { @@ -44,15 +41,10 @@ func TestRcmgr(t *testing.T) { }) node.StartDaemon() - t.Run("swarm limit should fail", func(t *testing.T) { - res := node.RunIPFS("swarm", "limit", "system") - assert.Equal(t, 1, res.ExitCode()) - assert.Contains(t, res.Stderr.Lines()[0], "missing ResourceMgr") - }) - t.Run("swarm stats should fail", func(t *testing.T) { - res := node.RunIPFS("swarm", "stats", "all") + t.Run("swarm resources should fail", func(t *testing.T) { + res := node.RunIPFS("swarm", "resources") assert.Equal(t, 1, res.ExitCode()) - assert.Contains(t, res.Stderr.Lines()[0], "missing ResourceMgr") + assert.Contains(t, res.Stderr.String(), "missing ResourceMgr") }) }) @@ -63,12 +55,14 @@ func TestRcmgr(t *testing.T) { }) node.StartDaemon() - res := node.RunIPFS("swarm", "limit", "system", "--enc=json") + res := node.RunIPFS("swarm", "resources", "--enc=json") require.Equal(t, 0, res.ExitCode()) limits := unmarshalLimits(t, res.Stdout.Bytes()) - assert.GreaterOrEqual(t, limits.ConnsInbound, 2000) - assert.GreaterOrEqual(t, limits.StreamsInbound, 2000) + rl := limits.System.ToResourceLimits() + s := rl.Build(rcmgr.BaseLimit{}) + assert.GreaterOrEqual(t, s.ConnsInbound, 2000) + assert.GreaterOrEqual(t, s.StreamsInbound, 2000) }) t.Run("default configuration", func(t *testing.T) { @@ -80,176 +74,102 @@ func TestRcmgr(t *testing.T) { node.StartDaemon() t.Run("conns and streams are above 800 for default connmgr settings", func(t *testing.T) { - res := node.RunIPFS("swarm", "limit", "system", "--enc=json") + res := node.RunIPFS("swarm", "resources", "--enc=json") require.Equal(t, 0, res.ExitCode()) limits := unmarshalLimits(t, res.Stdout.Bytes()) - assert.GreaterOrEqual(t, limits.ConnsInbound, 800) - assert.GreaterOrEqual(t, limits.StreamsInbound, 800) + if limits.System.ConnsInbound != rcmgr.Unlimited { + assert.GreaterOrEqual(t, limits.System.ConnsInbound, 800) + } + if limits.System.StreamsInbound != rcmgr.Unlimited { + assert.GreaterOrEqual(t, limits.System.StreamsInbound, 800) + } }) - t.Run("limits|stats should succeed", func(t *testing.T) { - res := node.RunIPFS("swarm", "limit", "all") + t.Run("limits should succeed", func(t *testing.T) { + res := node.RunIPFS("swarm", "resources", "--enc=json") assert.Equal(t, 0, res.ExitCode()) - limits := map[string]rcmgr.ResourceLimits{} + limits := rcmgr.PartialLimitConfig{} err := json.Unmarshal(res.Stdout.Bytes(), &limits) require.NoError(t, err) - assert.Greater(t, limits["System"].Memory, int64(0)) - assert.Greater(t, limits["System"].FD, 0) - assert.Greater(t, limits["System"].Conns, 0) - assert.Greater(t, limits["System"].ConnsInbound, 0) - assert.Greater(t, limits["System"].ConnsOutbound, 0) - assert.Greater(t, limits["System"].Streams, 0) - assert.Greater(t, limits["System"].StreamsInbound, 0) - assert.Greater(t, limits["System"].StreamsOutbound, 0) - assert.Greater(t, limits["Transient"].Memory, int64(0)) - }) - - t.Run("resetting limits should produce the same default limits", func(t *testing.T) { - resetRes := node.RunIPFS("swarm", "limit", "system", "--reset", "--enc=json") - require.Equal(t, 0, resetRes.ExitCode()) - limitRes := node.RunIPFS("swarm", "limit", "system", "--enc=json") - require.Equal(t, 0, limitRes.ExitCode()) - - assert.Equal(t, resetRes.Stdout.Bytes(), limitRes.Stdout.Bytes()) - }) - - t.Run("swarm stats system with filter should fail", func(t *testing.T) { - res := node.RunIPFS("swarm", "stats", "system", "--min-used-limit-perc=99") - assert.Equal(t, 1, res.ExitCode()) - assert.Contains(t, res.Stderr.Lines()[0], `Error: "min-used-limit-perc" can only be used when scope is "all"`) - }) - - t.Run("swarm limit reset on map values should work", func(t *testing.T) { - resetRes := node.RunIPFS("swarm", "limit", "peer:12D3KooWL7i1T9VSPeF8AgQApbyM51GNKZsYPvNvL347aMDmvNzG", "--reset", "--enc=json") - require.Equal(t, 0, resetRes.ExitCode()) - limitRes := node.RunIPFS("swarm", "limit", "peer:12D3KooWL7i1T9VSPeF8AgQApbyM51GNKZsYPvNvL347aMDmvNzG", "--enc=json") - require.Equal(t, 0, limitRes.ExitCode()) - - assert.Equal(t, resetRes.Stdout.Bytes(), limitRes.Stdout.Bytes()) - }) - - t.Run("scope is required using reset flags", func(t *testing.T) { - res := node.RunIPFS("swarm", "limit", "--reset") - assert.Equal(t, 1, res.ExitCode()) - assert.Contains(t, res.Stderr.Lines()[0], `Error: argument "scope" is required`) + assert.NotEqual(t, limits.Transient.Memory, rcmgr.BlockAllLimit64) + assert.NotEqual(t, limits.System.Memory, rcmgr.BlockAllLimit64) + assert.NotEqual(t, limits.System.FD, rcmgr.BlockAllLimit) + assert.NotEqual(t, limits.System.Conns, rcmgr.BlockAllLimit) + assert.NotEqual(t, limits.System.ConnsInbound, rcmgr.BlockAllLimit) + assert.NotEqual(t, limits.System.ConnsOutbound, rcmgr.BlockAllLimit) + assert.NotEqual(t, limits.System.Streams, rcmgr.BlockAllLimit) + assert.NotEqual(t, limits.System.StreamsInbound, rcmgr.BlockAllLimit) + assert.NotEqual(t, limits.System.StreamsOutbound, rcmgr.BlockAllLimit) }) t.Run("swarm stats works", func(t *testing.T) { - res := node.RunIPFS("swarm", "stats", "all", "--enc=json") + res := node.RunIPFS("swarm", "resources", "--enc=json") require.Equal(t, 0, res.ExitCode()) - stats := libp2p.NetStatOut{} - err := json.Unmarshal(res.Stdout.Bytes(), &stats) - require.NoError(t, err) + limits := unmarshalLimits(t, res.Stdout.Bytes()) // every scope has the same fields, so we only inspect system - assert.Equal(t, rcmgr.LimitVal64(0), stats.System.Memory) - assert.Equal(t, rcmgr.LimitVal(0), stats.System.FD) - assert.Equal(t, rcmgr.LimitVal(0), stats.System.Conns) - assert.Equal(t, rcmgr.LimitVal(0), stats.System.ConnsInbound) - assert.Equal(t, rcmgr.LimitVal(0), stats.System.ConnsOutbound) - assert.Equal(t, rcmgr.LimitVal(0), stats.System.Streams) - assert.Equal(t, rcmgr.LimitVal(0), stats.System.StreamsInbound) - assert.Equal(t, rcmgr.LimitVal(0), stats.System.StreamsOutbound) - assert.Equal(t, rcmgr.LimitVal64(0), stats.Transient.Memory) + assert.Zero(t, limits.System.MemoryUsage) + assert.Zero(t, limits.System.FDUsage) + assert.Zero(t, limits.System.ConnsInboundUsage) + assert.Zero(t, limits.System.ConnsOutboundUsage) + assert.Zero(t, limits.System.StreamsInboundUsage) + assert.Zero(t, limits.System.StreamsOutboundUsage) + assert.Zero(t, limits.Transient.MemoryUsage) }) }) - t.Run("set system conns limit while daemon is not running", func(t *testing.T) { + t.Run("smoke test transient scope", func(t *testing.T) { node := harness.NewT(t).NewNode().Init() - res := node.RunIPFS("config", "--json", "Swarm.ResourceMgr.Limits.System.Conns", "99999") - require.Equal(t, 0, res.ExitCode()) - - t.Run("set an invalid limit which should result in a failure", func(t *testing.T) { - res := node.RunIPFS("config", "--json", "Swarm.ResourceMgr.Limits.System.Conns", "asdf") - assert.Equal(t, 1, res.ExitCode()) - assert.Contains(t, res.Stderr.String(), "failed to unmarshal") + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { + overrides.Transient.Memory = 88888 }) - node.StartDaemon() - t.Run("new system conns limit is applied", func(t *testing.T) { - res := node.RunIPFS("swarm", "limit", "system", "--enc=json") - limits := unmarshalLimits(t, res.Stdout.Bytes()) - assert.Equal(t, limits.Conns, rcmgr.LimitVal(99999)) - }) - }) - - t.Run("set the system memory limit while the daemon is running", func(t *testing.T) { - node := harness.NewT(t).NewNode().Init().StartDaemon() - updateLimitsWithFile(t, node, "system", func(limits *rcmgr.ResourceLimits) { - limits.Memory = 99998 - }) - - assert.Equal(t, rcmgr.LimitVal64(99998), node.ReadConfig().Swarm.ResourceMgr.Limits.System.Memory) - - res := node.RunIPFS("swarm", "limit", "system", "--enc=json") - limits := unmarshalLimits(t, res.Stdout.Bytes()) - assert.Equal(t, rcmgr.LimitVal64(99998), limits.Memory) - }) - - t.Run("smoke test transient scope", func(t *testing.T) { - node := harness.NewT(t).NewNode().Init().StartDaemon() - updateLimitsWithFile(t, node, "transient", func(limits *rcmgr.ResourceLimits) { - limits.Memory = 88888 - }) - - res := node.RunIPFS("swarm", "limit", "transient", "--enc=json") + res := node.RunIPFS("swarm", "resources", "--enc=json") limits := unmarshalLimits(t, res.Stdout.Bytes()) - assert.Equal(t, rcmgr.LimitVal64(88888), limits.Memory) + assert.Equal(t, rcmgr.LimitVal64(88888), limits.Transient.Memory) }) t.Run("smoke test service scope", func(t *testing.T) { - node := harness.NewT(t).NewNode().Init().StartDaemon() - updateLimitsWithFile(t, node, "svc:foo", func(limits *rcmgr.ResourceLimits) { - limits.Memory = 77777 + node := harness.NewT(t).NewNode().Init() + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { + overrides.Service = map[string]rcmgr.ResourceLimits{"foo": {Memory: 77777}} }) + node.StartDaemon() - res := node.RunIPFS("swarm", "limit", "svc:foo", "--enc=json") + res := node.RunIPFS("swarm", "resources", "--enc=json") limits := unmarshalLimits(t, res.Stdout.Bytes()) - assert.Equal(t, rcmgr.LimitVal64(77777), limits.Memory) + assert.Equal(t, rcmgr.LimitVal64(77777), limits.Services["foo"].Memory) }) t.Run("smoke test protocol scope", func(t *testing.T) { - node := harness.NewT(t).NewNode().Init().StartDaemon() - updateLimitsWithFile(t, node, "proto:foo", func(limits *rcmgr.ResourceLimits) { - limits.Memory = 66666 + node := harness.NewT(t).NewNode().Init() + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { + overrides.Protocol = map[protocol.ID]rcmgr.ResourceLimits{"foo": {Memory: 66666}} }) + node.StartDaemon() - res := node.RunIPFS("swarm", "limit", "proto:foo", "--enc=json") + res := node.RunIPFS("swarm", "resources", "--enc=json") limits := unmarshalLimits(t, res.Stdout.Bytes()) - assert.Equal(t, rcmgr.LimitVal64(66666), limits.Memory) + assert.Equal(t, rcmgr.LimitVal64(66666), limits.Protocols["foo"].Memory) }) t.Run("smoke test peer scope", func(t *testing.T) { - validPeerID := "QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN" - node := harness.NewT(t).NewNode().Init().StartDaemon() - updateLimitsWithFile(t, node, "peer:"+validPeerID, func(limits *rcmgr.ResourceLimits) { - limits.Memory = 66666 + validPeerID, err := peer.Decode("QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN") + assert.NoError(t, err) + node := harness.NewT(t).NewNode().Init() + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { + overrides.Peer = map[peer.ID]rcmgr.ResourceLimits{validPeerID: {Memory: 55555}} }) + node.StartDaemon() - res := node.RunIPFS("swarm", "limit", "peer:"+validPeerID, "--enc=json") + res := node.RunIPFS("swarm", "resources", "--enc=json") limits := unmarshalLimits(t, res.Stdout.Bytes()) - assert.Equal(t, rcmgr.LimitVal64(66666), limits.Memory) - - t.Parallel() - - t.Run("getting limit for invalid peer ID fails", func(t *testing.T) { - res := node.RunIPFS("swarm", "limit", "peer:foo") - assert.Equal(t, 1, res.ExitCode()) - assert.Contains(t, res.Stderr.String(), "invalid peer ID") - }) - - t.Run("setting limit for invalid peer ID fails", func(t *testing.T) { - filename := "invalid-peer-id.json" - node.WriteBytes(filename, []byte(`{"Memory":"99"}`)) - res := node.RunIPFS("swarm", "limit", "peer:foo", filename) - assert.Equal(t, 1, res.ExitCode()) - assert.Contains(t, res.Stderr.String(), "invalid peer ID") - }) + assert.Equal(t, rcmgr.LimitVal64(55555), limits.Peers[validPeerID].Memory) }) t.Run("", func(t *testing.T) { @@ -258,20 +178,20 @@ func TestRcmgr(t *testing.T) { // peerID0, peerID1, peerID2 := node0.PeerID(), node1.PeerID(), node2.PeerID() peerID1, peerID2 := node1.PeerID().String(), node2.PeerID().String() - node0.UpdateConfig(func(cfg *config.Config) { + node0.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + *overrides = rcmgr.PartialLimitConfig{ + System: rcmgr.ResourceLimits{ + Conns: rcmgr.BlockAllLimit, + ConnsInbound: rcmgr.BlockAllLimit, + ConnsOutbound: rcmgr.BlockAllLimit, + }, + } cfg.Swarm.ResourceMgr.Enabled = config.True cfg.Swarm.ResourceMgr.Allowlist = []string{"/ip4/0.0.0.0/ipcidr/0/p2p/" + peerID2} }) nodes.StartDaemons() - // change system limits on node 0 - updateLimitsWithFile(t, node0, "system", func(limits *rcmgr.ResourceLimits) { - limits.Conns = rcmgr.BlockAllLimit - limits.ConnsInbound = rcmgr.BlockAllLimit - limits.ConnsOutbound = rcmgr.BlockAllLimit - }) - t.Parallel() t.Run("node 0 should fail to connect to node 1", func(t *testing.T) { res := node0.Runner.Run(harness.RunRequest{ @@ -306,9 +226,10 @@ func TestRcmgr(t *testing.T) { t.Parallel() t.Run("system conns", func(t *testing.T) { node := harness.NewT(t).NewNode().Init() - node.UpdateConfig(func(cfg *config.Config) { - cfg.Swarm.ResourceMgr.Limits = &rcmgr.PartialLimitConfig{} - cfg.Swarm.ResourceMgr.Limits.System.Conns = 128 + node.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + *overrides = rcmgr.PartialLimitConfig{ + System: rcmgr.ResourceLimits{Conns: 128}, + } cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) }) @@ -318,9 +239,10 @@ func TestRcmgr(t *testing.T) { }) t.Run("system conns inbound", func(t *testing.T) { node := harness.NewT(t).NewNode().Init() - node.UpdateConfig(func(cfg *config.Config) { - cfg.Swarm.ResourceMgr.Limits = &rcmgr.PartialLimitConfig{} - cfg.Swarm.ResourceMgr.Limits.System.ConnsInbound = 128 + node.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + *overrides = rcmgr.PartialLimitConfig{ + System: rcmgr.ResourceLimits{ConnsInbound: 128}, + } cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) }) @@ -330,9 +252,10 @@ func TestRcmgr(t *testing.T) { }) t.Run("system streams", func(t *testing.T) { node := harness.NewT(t).NewNode().Init() - node.UpdateConfig(func(cfg *config.Config) { - cfg.Swarm.ResourceMgr.Limits = &rcmgr.PartialLimitConfig{} - cfg.Swarm.ResourceMgr.Limits.System.Streams = 128 + node.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + *overrides = rcmgr.PartialLimitConfig{ + System: rcmgr.ResourceLimits{Streams: 128}, + } cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) }) @@ -342,9 +265,10 @@ func TestRcmgr(t *testing.T) { }) t.Run("system streams inbound", func(t *testing.T) { node := harness.NewT(t).NewNode().Init() - node.UpdateConfig(func(cfg *config.Config) { - cfg.Swarm.ResourceMgr.Limits = &rcmgr.PartialLimitConfig{} - cfg.Swarm.ResourceMgr.Limits.System.StreamsInbound = 128 + node.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + *overrides = rcmgr.PartialLimitConfig{ + System: rcmgr.ResourceLimits{StreamsInbound: 128}, + } cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) }) @@ -355,22 +279,8 @@ func TestRcmgr(t *testing.T) { }) } -func updateLimitsWithFile(t *testing.T, node *harness.Node, limit string, f func(*rcmgr.ResourceLimits)) { - filename := limit + ".json" - res := node.RunIPFS("swarm", "limit", limit) - limits := unmarshalLimits(t, res.Stdout.Bytes()) - - f(limits) - - limitsOut, err := json.Marshal(limits) - require.NoError(t, err) - node.WriteBytes(filename, limitsOut) - res = node.RunIPFS("swarm", "limit", limit, filename) - assert.Equal(t, 0, res.ExitCode()) -} - -func unmarshalLimits(t *testing.T, b []byte) *rcmgr.ResourceLimits { - limits := &rcmgr.ResourceLimits{} +func unmarshalLimits(t *testing.T, b []byte) *libp2p.LimitsConfigAndUsage { + limits := &libp2p.LimitsConfigAndUsage{} err := json.Unmarshal(b, limits) require.NoError(t, err) return limits diff --git a/test/sharness/t0060-daemon.sh b/test/sharness/t0060-daemon.sh index ca40fd0d110..b237e143f66 100755 --- a/test/sharness/t0060-daemon.sh +++ b/test/sharness/t0060-daemon.sh @@ -81,12 +81,11 @@ test_expect_success "ipfs daemon output looks good" ' echo "Initializing daemon..." >expected_daemon && ipfs version --all >> expected_daemon && echo "" >>expected_daemon && - echo "Computing default go-libp2p Resource Manager limits based on:" >>expected_daemon && + echo "Computed default go-libp2p Resource Manager limits based on:" >>expected_daemon && echo " - '"'"'Swarm.ResourceMgr.MaxMemory'"'"': \"4GB\"" >>expected_daemon && echo " - '"'"'Swarm.ResourceMgr.MaxFileDescriptors'"'"': 1024" >>expected_daemon && echo "" >>expected_daemon && - echo "Applying any user-supplied overrides on top." >>expected_daemon && - echo "Run '"'"'ipfs swarm limit all'"'"' to see the resulting limits." >>expected_daemon && + echo "Theses can be inspected with '"'"'ipfs swarm resources'"'"'." >>expected_daemon && echo "" >>expected_daemon && sed "s/^/Swarm listening on /" listen_addrs >>expected_daemon && sed "s/^/Swarm announcing /" local_addrs >>expected_daemon && From 0f1181d23218fe2d8263eb1eab9c415ff5ea57c0 Mon Sep 17 00:00:00 2001 From: galargh Date: Mon, 6 Mar 2023 12:30:18 +0000 Subject: [PATCH 33/93] chore: update version --- version.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/version.go b/version.go index 1f0577fa3a2..71912f891d6 100644 --- a/version.go +++ b/version.go @@ -11,7 +11,7 @@ import ( var CurrentCommit string // CurrentVersionNumber is the current application's version literal -const CurrentVersionNumber = "0.19.0-dev" +const CurrentVersionNumber = "0.19.0-rc1" const ApiVersion = "/kubo/" + CurrentVersionNumber + "/" //nolint From 5e8fb41151ca66f1eb127417e61974936a588eec Mon Sep 17 00:00:00 2001 From: galargh Date: Mon, 6 Mar 2023 12:30:37 +0000 Subject: [PATCH 34/93] chore: update version --- version.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/version.go b/version.go index 1f0577fa3a2..992f4a9885b 100644 --- a/version.go +++ b/version.go @@ -11,7 +11,7 @@ import ( var CurrentCommit string // CurrentVersionNumber is the current application's version literal -const CurrentVersionNumber = "0.19.0-dev" +const CurrentVersionNumber = "0.20.0-dev" const ApiVersion = "/kubo/" + CurrentVersionNumber + "/" //nolint From 698166bf2ad349f11bb2df6b95e41c3df22863a8 Mon Sep 17 00:00:00 2001 From: omahs <73983677+omahs@users.noreply.github.com> Date: Mon, 6 Mar 2023 15:42:54 +0100 Subject: [PATCH 35/93] docs: fix typos --- docs/RELEASE_ISSUE_TEMPLATE.md | 10 +++++----- docs/config.md | 6 +++--- docs/delegated-routing.md | 2 +- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/docs/RELEASE_ISSUE_TEMPLATE.md b/docs/RELEASE_ISSUE_TEMPLATE.md index da3ec3e1830..cb5c966a8cb 100644 --- a/docs/RELEASE_ISSUE_TEMPLATE.md +++ b/docs/RELEASE_ISSUE_TEMPLATE.md @@ -93,7 +93,7 @@ Checklist: - PR will be merged automatically once the diff is approved - `master` build will publish the artifacts to https://dist.ipfs.io in around 30 minutes - [ ] Ensure that the artifacts are available at https://dist.ipfs.io - - [ ] Publish the RC to [the NPM package](https://www.npmjs.com/package/go-ipfs?activeTab=versions) by running https://github.com/ipfs/npm-go-ipfs/actions/workflows/main.yml (it happens automatically but it is safe to speed up the process and kick of a run manually) + - [ ] Publish the RC to [the NPM package](https://www.npmjs.com/package/go-ipfs?activeTab=versions) by running https://github.com/ipfs/npm-go-ipfs/actions/workflows/main.yml (it happens automatically but it is safe to speed up the process and kick off a run manually) - [ ] Cut a pre-release on [GitHub](https://github.com/ipfs/kubo/releases) ([instructions](https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository#creating-a-release), [example](https://github.com/ipfs/kubo/releases/tag/v0.17.0-rc1)) - Use `vX.Y.Z-rcN` as the tag. - Link to the release issue in the description. @@ -120,7 +120,7 @@ Checklist: - [ ] [Optional] Reply under a message about the issue in the #bifrost channel on FIL Slack once the RC is out. Send the message to the channel. - [ ] Check [metrics](https://protocollabs.grafana.net/d/8zlhkKTZk/gateway-slis-precomputed?orgId=1) every day. - Compare the metrics trends week over week. - - If there is an unexpected variation in the trend, message the #bifrost channel on FIL Slack and ask for help investigation the cause. + - If there is an unexpected variation in the trend, message the #bifrost channel on FIL Slack and ask for help investigating the cause. - [ ] IPFS Application Testing. - [ ] [IPFS Desktop](https://github.com/ipfs-shipyard/ipfs-desktop) - [ ] Upgrade to the RC in [ipfs-desktop](https://github.com/ipfs-shipyard/ipfs-desktop) @@ -133,13 +133,13 @@ Checklist: - [ ] Start a fresh chromium or chrome instance using `chromium --user-data-dir=$(mktemp -d)` (macos `/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --user-data-dir=$(mktemp -d)`) - [ ] Start a fresh firefox instance using `firefox --profile $(mktemp -d)` (macos `/Applications/Firefox.app/Contents/MacOS/firefox --profile $(mktemp -d)`) - [ ] Install IPFS Companion from [vendor-specific store](https://github.com/ipfs/ipfs-companion/#readme). - - [ ] Check that the comunication between Kubo daemon and IPFS companion is working properly checking if the number of connected peers changes. + - [ ] Check that the communication between Kubo daemon and IPFS companion is working properly checking if the number of connected peers changes. - [ ] **Stage 5 - Release** - _ONLY FOR FINAL RELEASE_ - [ ] Prepare the `release` branch. - [ ] Bump the version in `version.go` in the `release-vX.Y.Z` branch to `X.Y.Z`. - [ ] Update the [docs/changelogs/vX.Y.md](docs/changelogs) with the new commits and contributors. - [ ] Run `./bin/mkreleaselog` twice to generate the changelog and copy the output. - - The first run of the script might be poluted with `git clone` output. + - The first run of the script might be polluted with `git clone` output. - [ ] Paste the output into the `### Changelog` section of the changelog file inside the `
` block. - [ ] Commit the changelog changes. - [ ] Push the `release-vX.Y.Z` branch to GitHub (`git push origin release-vX.Y.Z`) @@ -169,7 +169,7 @@ Checklist: - PR will be merged automatically once the diff is approved - `master` build will publish the artifacts to https://dist.ipfs.io in around 30 minutes - [ ] Ensure that the artifacts are available at https://dist.ipfs.io - - [ ] Publish the release to [the NPM package](https://www.npmjs.com/package/go-ipfs?activeTab=versions) by running https://github.com/ipfs/npm-go-ipfs/actions/workflows/main.yml (it happens automatically but it is safe to speed up the process and kick of a run manually) + - [ ] Publish the release to [the NPM package](https://www.npmjs.com/package/go-ipfs?activeTab=versions) by running https://github.com/ipfs/npm-go-ipfs/actions/workflows/main.yml (it happens automatically but it is safe to speed up the process and kick off a run manually) - [ ] Cut the release on [GitHub](https://github.com/ipfs/kubo/releases) ([instructions](https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository#creating-a-release), [example](https://github.com/ipfs/kubo/releases/tag/v0.17.0)) - Use `vX.Y.Z` as the tag. - Copy the relevant [changelog](https://github.com/ipfs/kubo/blob/release/docs/changelogs/) into the release description. diff --git a/docs/config.md b/docs/config.md index 30a4e760134..adf956ce01d 100644 --- a/docs/config.md +++ b/docs/config.md @@ -454,7 +454,7 @@ Type: `string` (one of `"enabled"` or `"disabled"`) ### `AutoNAT.Throttle` -When set, this option configure's the AutoNAT services throttling behavior. By +When set, this option configures the AutoNAT services throttling behavior. By default, Kubo will rate-limit the number of NAT checks performed for other nodes to 30 per minute, and 3 per peer. @@ -616,7 +616,7 @@ Type: `bool` #### `Discovery.MDNS.Interval` -**REMOVED:** this is not configurable any more +**REMOVED:** this is not configurable anymore in the [new mDNS implementation](https://github.com/libp2p/zeroconf#readme). ## `Experimental` @@ -966,7 +966,7 @@ Type: `optionalInteger` (thread count, `null` means default which is 8) #### `Internal.Bitswap.MaxOutstandingBytesPerPeer` Maximum number of bytes (across all tasks) pending to be processed and sent to any individual peer. -This number controls fairness and can very from 250Kb (very fair) to 10Mb (less fair, with more work +This number controls fairness and can vary from 250Kb (very fair) to 10Mb (less fair, with more work dedicated to peers who ask for more). Values below 250Kb could cause thrashing. Values above 10Mb open the potential for aggressively-wanting peers to consume all resources and deteriorate the quality provided to less aggressively-wanting peers. diff --git a/docs/delegated-routing.md b/docs/delegated-routing.md index ff58aa8f97b..32f7a755267 100644 --- a/docs/delegated-routing.md +++ b/docs/delegated-routing.md @@ -13,7 +13,7 @@ Now we need a better way to add different routers using different protocols like ## Motivation -The actual routing implementation is not enough. Some users needs to have more options when configuring the routing system. The new implementations should be able to: +The actual routing implementation is not enough. Some users need to have more options when configuring the routing system. The new implementations should be able to: - [x] Be user-friendly and easy enough to configure, but also versatile - [x] Configurable Router execution order From 6d7ad617477ea52d611bbd2eb8c044f0fc22451c Mon Sep 17 00:00:00 2001 From: Will Hawkins Date: Mon, 14 Nov 2022 14:17:04 +0000 Subject: [PATCH 36/93] fix: typo in documentation for install path By default, `go install` will install go $GOBIN and not $GOPATH/bin. In most cases there is no functional difference -- `go install` falls back to $GOPATH/bin when $GOBIN is empty. --- Rules.mk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rules.mk b/Rules.mk index f7e962549c8..3d3d9c13951 100644 --- a/Rules.mk +++ b/Rules.mk @@ -118,7 +118,7 @@ help: @echo ' all - print this help message' @echo ' build - Build binary at ./cmd/ipfs/ipfs' @echo ' nofuse - Build binary with no fuse support' - @echo ' install - Build binary and install into $$GOPATH/bin' + @echo ' install - Build binary and install into $$GOBIN' # @echo ' dist_install - TODO: c.f. ./cmd/ipfs/dist/README.md' @echo '' @echo 'CLEANING TARGETS:' From 0ee879ec69ccb95de7c57f5da48a05adc4d70f75 Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Mon, 6 Mar 2023 19:45:23 +0100 Subject: [PATCH 37/93] docs: sort early testers list alphabetically --- docs/EARLY_TESTERS.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/EARLY_TESTERS.md b/docs/EARLY_TESTERS.md index fb2fedc2a33..b9bb1fa4547 100644 --- a/docs/EARLY_TESTERS.md +++ b/docs/EARLY_TESTERS.md @@ -22,15 +22,15 @@ We will ask early testers to participate at two points in the process: ## Who has signed up? -- [ ] pacman.store (@RubenKelevra) +- [ ] Charity Engine (@rytiss, @tristanolive) +- [ ] Fission (@bmann) - [ ] Infura (@MichaelMure) -- [ ] Textile (@sanderpick) +- [ ] OrbitDB (@aphelionz) +- [ ] pacman.store (@RubenKelevra) - [ ] Pinata (@obo20) - [ ] RTrade (@postables) - [ ] Siderus (@koalalorenzo) -- [ ] Charity Engine (@rytiss, @tristanolive) -- [ ] Fission (@bmann) -- [ ] OrbitDB (@aphelionz) +- [ ] Textile (@sanderpick) ## How to sign up? From 4400db6ce425bd6db5268c3350a923315da96eb0 Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Mon, 6 Mar 2023 19:48:39 +0100 Subject: [PATCH 38/93] docs: add bifrost to early testers --- docs/EARLY_TESTERS.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/EARLY_TESTERS.md b/docs/EARLY_TESTERS.md index b9bb1fa4547..d0dd4a8672e 100644 --- a/docs/EARLY_TESTERS.md +++ b/docs/EARLY_TESTERS.md @@ -28,6 +28,7 @@ We will ask early testers to participate at two points in the process: - [ ] OrbitDB (@aphelionz) - [ ] pacman.store (@RubenKelevra) - [ ] Pinata (@obo20) +- [ ] PL EngRes bifrost (@gmasgras) - [ ] RTrade (@postables) - [ ] Siderus (@koalalorenzo) - [ ] Textile (@sanderpick) From 0f65594d9e8e8803eb306d40a46c4b19221ffd9e Mon Sep 17 00:00:00 2001 From: Alex Date: Tue, 7 Mar 2023 23:01:49 +0000 Subject: [PATCH 39/93] Apply suggestions from code review Co-authored-by: Piotr Galar --- .github/workflows/codeql-analysis.yml | 4 +--- .github/workflows/sync-release-assets.yml | 5 ++--- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml index c5bbc1c2c83..7cd6c4003b1 100644 --- a/.github/workflows/codeql-analysis.yml +++ b/.github/workflows/codeql-analysis.yml @@ -13,12 +13,10 @@ on: permissions: contents: read # to fetch code (actions/checkout) + security-events: write # (github/codeql-action/autobuild) jobs: analyze: - permissions: - contents: read # to fetch code (actions/checkout) - security-events: write # (github/codeql-action/autobuild) if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' name: Analyze diff --git a/.github/workflows/sync-release-assets.yml b/.github/workflows/sync-release-assets.yml index 0a7f2e6268d..1e9b51a3a1b 100644 --- a/.github/workflows/sync-release-assets.yml +++ b/.github/workflows/sync-release-assets.yml @@ -9,11 +9,10 @@ concurrency: group: release-assets-dist-sync cancel-in-progress: true -permissions: {} +permissions: + contents: write # to upload release asset jobs: sync-github-and-dist-ipfs-tech: - permissions: - contents: write # to upload release asset if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' runs-on: "ubuntu-latest" From b21e819923c7f0852791534fcf140cbc29185845 Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Wed, 8 Mar 2023 08:00:44 +0100 Subject: [PATCH 40/93] Apply suggestions from code review --- .github/workflows/codeql-analysis.yml | 1 - .github/workflows/sync-release-assets.yml | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml index 7cd6c4003b1..e732a11482a 100644 --- a/.github/workflows/codeql-analysis.yml +++ b/.github/workflows/codeql-analysis.yml @@ -17,7 +17,6 @@ permissions: jobs: analyze: - if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' name: Analyze runs-on: ubuntu-latest diff --git a/.github/workflows/sync-release-assets.yml b/.github/workflows/sync-release-assets.yml index 1e9b51a3a1b..0c295d80457 100644 --- a/.github/workflows/sync-release-assets.yml +++ b/.github/workflows/sync-release-assets.yml @@ -11,9 +11,9 @@ concurrency: permissions: contents: write # to upload release asset + jobs: sync-github-and-dist-ipfs-tech: - if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' runs-on: "ubuntu-latest" timeout-minutes: 5 From 40d7f2feccd7b59e476717e8f7730f521f70ebba Mon Sep 17 00:00:00 2001 From: Jorropo Date: Tue, 7 Mar 2023 19:28:52 +0100 Subject: [PATCH 41/93] chore: bump go-libipfs v0.6.1 This does nothing, just move from an untagged commit to a tagged commit but contain the same things. --- docs/examples/kubo-as-a-library/go.mod | 2 +- docs/examples/kubo-as-a-library/go.sum | 4 ++-- go.mod | 2 +- go.sum | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/examples/kubo-as-a-library/go.mod b/docs/examples/kubo-as-a-library/go.mod index 056aea33467..1c19dd3eb94 100644 --- a/docs/examples/kubo-as-a-library/go.mod +++ b/docs/examples/kubo-as-a-library/go.mod @@ -7,7 +7,7 @@ go 1.18 replace github.com/ipfs/kubo => ./../../.. require ( - github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 + github.com/ipfs/go-libipfs v0.6.1 github.com/ipfs/interface-go-ipfs-core v0.11.0 github.com/ipfs/kubo v0.0.0-00010101000000-000000000000 github.com/libp2p/go-libp2p v0.26.2 diff --git a/docs/examples/kubo-as-a-library/go.sum b/docs/examples/kubo-as-a-library/go.sum index 8a07bfbe87a..c927b58d90e 100644 --- a/docs/examples/kubo-as-a-library/go.sum +++ b/docs/examples/kubo-as-a-library/go.sum @@ -569,8 +569,8 @@ github.com/ipfs/go-ipld-legacy v0.1.1 h1:BvD8PEuqwBHLTKqlGFTHSwrwFOMkVESEvwIYwR2 github.com/ipfs/go-ipld-legacy v0.1.1/go.mod h1:8AyKFCjgRPsQFf15ZQgDB8Din4DML/fOmKZkkFkrIEg= github.com/ipfs/go-ipns v0.3.0 h1:ai791nTgVo+zTuq2bLvEGmWP1M0A6kGTXUsgv/Yq67A= github.com/ipfs/go-ipns v0.3.0/go.mod h1:3cLT2rbvgPZGkHJoPO1YMJeh6LtkxopCkKFcio/wE24= -github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 h1:QRLcCoITO9ZQo2pvjmrfngqKhUKjPopBva3MVH62LT8= -github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260/go.mod h1:3OoEQs95UkqFEf65SbRDpiMwuzI+C/jTsYQaHfBbJXI= +github.com/ipfs/go-libipfs v0.6.1 h1:OSO9cm1H3r4OXfP0MP1Q5UhTnhd2fByGl6CVYyz/Rhk= +github.com/ipfs/go-libipfs v0.6.1/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk= github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A= diff --git a/go.mod b/go.mod index 34603ebd2d4..673dd3793bd 100644 --- a/go.mod +++ b/go.mod @@ -45,7 +45,7 @@ require ( github.com/ipfs/go-ipld-git v0.1.1 github.com/ipfs/go-ipld-legacy v0.1.1 github.com/ipfs/go-ipns v0.3.0 - github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 + github.com/ipfs/go-libipfs v0.6.1 github.com/ipfs/go-log v1.0.5 github.com/ipfs/go-log/v2 v2.5.1 github.com/ipfs/go-merkledag v0.9.0 diff --git a/go.sum b/go.sum index 6f7800a2e2a..16329d6ad3b 100644 --- a/go.sum +++ b/go.sum @@ -591,8 +591,8 @@ github.com/ipfs/go-ipld-legacy v0.1.1 h1:BvD8PEuqwBHLTKqlGFTHSwrwFOMkVESEvwIYwR2 github.com/ipfs/go-ipld-legacy v0.1.1/go.mod h1:8AyKFCjgRPsQFf15ZQgDB8Din4DML/fOmKZkkFkrIEg= github.com/ipfs/go-ipns v0.3.0 h1:ai791nTgVo+zTuq2bLvEGmWP1M0A6kGTXUsgv/Yq67A= github.com/ipfs/go-ipns v0.3.0/go.mod h1:3cLT2rbvgPZGkHJoPO1YMJeh6LtkxopCkKFcio/wE24= -github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 h1:QRLcCoITO9ZQo2pvjmrfngqKhUKjPopBva3MVH62LT8= -github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260/go.mod h1:3OoEQs95UkqFEf65SbRDpiMwuzI+C/jTsYQaHfBbJXI= +github.com/ipfs/go-libipfs v0.6.1 h1:OSO9cm1H3r4OXfP0MP1Q5UhTnhd2fByGl6CVYyz/Rhk= +github.com/ipfs/go-libipfs v0.6.1/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk= github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A= From f509e24984d0649d5079d6ad8c74c93a23cd09f2 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Wed, 8 Mar 2023 17:59:42 +0100 Subject: [PATCH 42/93] docs: add PubSub to changelog --- docs/changelogs/v0.19.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/docs/changelogs/v0.19.md b/docs/changelogs/v0.19.md index 7663308a6db..7a6274ee38d 100644 --- a/docs/changelogs/v0.19.md +++ b/docs/changelogs/v0.19.md @@ -7,6 +7,7 @@ - [Overview](#overview) - [🔦 Highlights](#-highlights) - [Improving the libp2p resource management integration](#improving-the-libp2p-resource-management-integration) + - [Pubsub message caching improvements](#pubsub-message-caching-improvements) - [📝 Changelog](#-changelog) - [👨‍👩‍👧‍👦 Contributors](#-contributors) @@ -22,6 +23,10 @@ and [0.18.1](https://github.com/ipfs/kubo/blob/master/docs/changelogs/v0.18.md#i - Note: we don't expect most users to need these capablities, but they are there if so. 1. [Doc updates](https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md). +#### PubSub message caching improvements + +The PubSub message cache will now [prune messages after TTL is exhausted](https://github.com/ipfs/kubo/blob/master/docs/config.md#pubsubseenmessagesttl), [either based on the last time a message was seen or the first time it was seen](https://github.com/ipfs/kubo/blob/master/docs/config.md#pubsubseenmessagesstrategy). + ### 📝 Changelog ### 👨‍👩‍👧‍👦 Contributors From fb663c6bb474a998bc4c0f56ef7c48dbe6c289e9 Mon Sep 17 00:00:00 2001 From: Marcin Rataj Date: Thu, 9 Mar 2023 00:24:46 +0100 Subject: [PATCH 43/93] docs: add IPIP-351 to 0.19 changelog --- docs/changelogs/v0.19.md | 45 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 44 insertions(+), 1 deletion(-) diff --git a/docs/changelogs/v0.19.md b/docs/changelogs/v0.19.md index 7a6274ee38d..3ce12e8d242 100644 --- a/docs/changelogs/v0.19.md +++ b/docs/changelogs/v0.19.md @@ -7,7 +7,10 @@ - [Overview](#overview) - [🔦 Highlights](#-highlights) - [Improving the libp2p resource management integration](#improving-the-libp2p-resource-management-integration) - - [Pubsub message caching improvements](#pubsub-message-caching-improvements) + - [PubSub message caching improvements](#pubsub-message-caching-improvements) + - [Gateways](#gateways) + - [Signed IPNS Record response format](#signed-ipns-record-response-format) + - [Example fetch and inspect IPNS record](#example-fetch-and-inspect-ipns-record) - [📝 Changelog](#-changelog) - [👨‍👩‍👧‍👦 Contributors](#-contributors) @@ -27,6 +30,46 @@ and [0.18.1](https://github.com/ipfs/kubo/blob/master/docs/changelogs/v0.18.md#i The PubSub message cache will now [prune messages after TTL is exhausted](https://github.com/ipfs/kubo/blob/master/docs/config.md#pubsubseenmessagesttl), [either based on the last time a message was seen or the first time it was seen](https://github.com/ipfs/kubo/blob/master/docs/config.md#pubsubseenmessagesstrategy). +#### Gateways + +##### Signed IPNS Record response format + +This release implements [IPIP-351](https://github.com/ipfs/specs/pull/351) and +adds Gateway support for returning signed (verifiable) `ipns-record` (0x0300) +when `/ipns/{libp2p-key}` is requested with either +`Accept: application/vnd.ipfs.ipns-record` HTTP header +or `?format=ipns-record` URL query parameter. + + +The Gateway in Kubo already supported [trustless, verifiable retrieval](https://docs.ipfs.tech/reference/http/gateway/#trustless-verifiable-retrieval) of immutable `/ipfs/` namespace. +With `?format=ipns-record`, light HTTP clients are now able to get the same level of verifiability for IPNS websites. + +Tooling is limited at the moment, but we are working on [go-libipfs](https://github.com/ipfs/go-libipfs/) examples that illustrate the verifiable HTTP client pattern. + +##### Example: fetch IPNS record over HTTP and inspect it with `ipfs name inspect --verify` + +```console +$ FILE_CID=$(echo "Hello IPFS" | ipfs add --cid-version 1 -q) +$ IPNS_KEY=$(ipfs key gen test) +$ ipfs name publish /ipfs/$FILE_CID --key=test --ttl=30m +Published to k51q..dvf1: /ipfs/bafk..z244 +$ curl "http://127.0.0.1:8080/ipns/$IPNS_KEY?format=ipns-record" > signed.ipns-record +$ ipfs name inspect --verify $IPNS_KEY < signed.ipns-record +Value: "/ipfs/bafk..." +Validity Type: "EOL" +Validity: 2023-03-09T23:13:34.032977468Z +Sequence: 0 +TTL: 1800000000000 +PublicKey: "" +Signature V1: "m..." +Signature V2: "m..." +Data: {...} + +Validation results: + Valid: true + PublicKey: 12D3... +``` + ### 📝 Changelog ### 👨‍👩‍👧‍👦 Contributors From ad5a0fea0e4627e66902c5ae5690892b67bf8d23 Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Wed, 8 Mar 2023 15:48:56 -0500 Subject: [PATCH 44/93] test: port legacy DHT tests to Go --- test/cli/dht_legacy_test.go | 137 ++++++++++++++++++++++++++++++ test/cli/harness/harness.go | 2 +- test/cli/harness/node.go | 44 +++++++--- test/cli/harness/nodes.go | 16 ++++ test/cli/harness/run.go | 8 +- test/sharness/t0170-legacy-dht.sh | 121 -------------------------- 6 files changed, 192 insertions(+), 136 deletions(-) create mode 100644 test/cli/dht_legacy_test.go delete mode 100755 test/sharness/t0170-legacy-dht.sh diff --git a/test/cli/dht_legacy_test.go b/test/cli/dht_legacy_test.go new file mode 100644 index 00000000000..437b62ae4ea --- /dev/null +++ b/test/cli/dht_legacy_test.go @@ -0,0 +1,137 @@ +package cli + +import ( + "sort" + "sync" + "testing" + + "github.com/ipfs/kubo/test/cli/harness" + "github.com/ipfs/kubo/test/cli/testutils" + "github.com/libp2p/go-libp2p/core/peer" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestLegacyDHT(t *testing.T) { + nodes := harness.NewT(t).NewNodes(5).Init() + nodes.ForEachPar(func(node *harness.Node) { + node.IPFS("config", "Routing.Type", "dht") + }) + nodes.StartDaemons().Connect() + + t.Run("ipfs dht findpeer", func(t *testing.T) { + t.Parallel() + res := nodes[1].RunIPFS("dht", "findpeer", nodes[0].PeerID().String()) + assert.Equal(t, 0, res.ExitCode()) + + swarmAddr := nodes[0].SwarmAddrsWithoutPeerIDs()[0] + require.Equal(t, swarmAddr.String(), res.Stdout.Trimmed()) + }) + + t.Run("ipfs dht get ", func(t *testing.T) { + t.Parallel() + hash := nodes[2].IPFSAddStr("hello world") + nodes[2].IPFS("name", "publish", "/ipfs/"+hash) + + res := nodes[1].IPFS("dht", "get", "/ipns/"+nodes[2].PeerID().String()) + assert.Contains(t, res.Stdout.String(), "/ipfs/"+hash) + + t.Run("put round trips (#3124)", func(t *testing.T) { + t.Parallel() + nodes[0].WriteBytes("get_result", res.Stdout.Bytes()) + res := nodes[0].IPFS("dht", "put", "/ipns/"+nodes[2].PeerID().String(), "get_result") + assert.Greater(t, len(res.Stdout.Lines()), 0, "should put to at least one node") + }) + + t.Run("put with bad keys fails (issue #5113, #4611)", func(t *testing.T) { + t.Parallel() + keys := []string{"foo", "/pk/foo", "/ipns/foo"} + for _, key := range keys { + key := key + t.Run(key, func(t *testing.T) { + t.Parallel() + res := nodes[0].RunIPFS("dht", "put", key) + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "invalid") + assert.Empty(t, res.Stdout.String()) + }) + } + }) + + t.Run("get with bad keys (issue #4611)", func(t *testing.T) { + for _, key := range []string{"foo", "/pk/foo"} { + key := key + t.Run(key, func(t *testing.T) { + t.Parallel() + res := nodes[0].RunIPFS("dht", "get", key) + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "invalid") + assert.Empty(t, res.Stdout.String()) + }) + } + }) + }) + + t.Run("ipfs dht findprovs", func(t *testing.T) { + t.Parallel() + hash := nodes[3].IPFSAddStr("some stuff") + res := nodes[4].IPFS("dht", "findprovs", hash) + assert.Equal(t, nodes[3].PeerID().String(), res.Stdout.Trimmed()) + }) + + t.Run("ipfs dht query ", func(t *testing.T) { + t.Parallel() + t.Run("normal DHT configuration", func(t *testing.T) { + t.Parallel() + hash := nodes[0].IPFSAddStr("some other stuff") + peerCounts := map[string]int{} + peerCountsMut := sync.Mutex{} + harness.Nodes(nodes).ForEachPar(func(node *harness.Node) { + res := node.IPFS("dht", "query", hash) + closestPeer := res.Stdout.Lines()[0] + // check that it's a valid peer ID + _, err := peer.Decode(closestPeer) + require.NoError(t, err) + + peerCountsMut.Lock() + peerCounts[closestPeer]++ + peerCountsMut.Unlock() + }) + // 4 nodes should see the same peer ID + // 1 node (the closest) should see a different one + var counts []int + for _, count := range peerCounts { + counts = append(counts, count) + } + sort.IntSlice(counts).Sort() + assert.Equal(t, []int{1, 4}, counts) + }) + + }) + + t.Run("dht commands fail when offline", func(t *testing.T) { + t.Parallel() + node := harness.NewT(t).NewNode().Init() + + // these cannot be run in parallel due to repo locking (seems like a bug) + + t.Run("dht findprovs", func(t *testing.T) { + res := node.RunIPFS("dht", "findprovs", testutils.CIDEmptyDir) + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "this command must be run in online mode") + }) + + t.Run("dht findpeer", func(t *testing.T) { + res := node.RunIPFS("dht", "findpeer", testutils.CIDEmptyDir) + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "this command must be run in online mode") + }) + + t.Run("dht put", func(t *testing.T) { + node.WriteBytes("foo", []byte("foo")) + res := node.RunIPFS("dht", "put", "/ipns/"+node.PeerID().String(), "foo") + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "this action must be run in online mode") + }) + }) +} diff --git a/test/cli/harness/harness.go b/test/cli/harness/harness.go index de962e1c120..a35fead3512 100644 --- a/test/cli/harness/harness.go +++ b/test/cli/harness/harness.go @@ -171,7 +171,7 @@ func (h *Harness) Mkdirs(paths ...string) { } } -func (h *Harness) Sh(expr string) RunResult { +func (h *Harness) Sh(expr string) *RunResult { return h.Runner.Run(RunRequest{ Path: "bash", Args: []string{"-c", expr}, diff --git a/test/cli/harness/node.go b/test/cli/harness/node.go index 0d0295307ff..181fca99bc4 100644 --- a/test/cli/harness/node.go +++ b/test/cli/harness/node.go @@ -129,23 +129,23 @@ func (n *Node) UpdateConfigAndUserSuppliedResourceManagerOverrides(f func(cfg *c n.WriteUserSuppliedResourceOverrides(overrides) } -func (n *Node) IPFS(args ...string) RunResult { +func (n *Node) IPFS(args ...string) *RunResult { res := n.RunIPFS(args...) n.Runner.AssertNoError(res) return res } -func (n *Node) PipeStrToIPFS(s string, args ...string) RunResult { +func (n *Node) PipeStrToIPFS(s string, args ...string) *RunResult { return n.PipeToIPFS(strings.NewReader(s), args...) } -func (n *Node) PipeToIPFS(reader io.Reader, args ...string) RunResult { +func (n *Node) PipeToIPFS(reader io.Reader, args ...string) *RunResult { res := n.RunPipeToIPFS(reader, args...) n.Runner.AssertNoError(res) return res } -func (n *Node) RunPipeToIPFS(reader io.Reader, args ...string) RunResult { +func (n *Node) RunPipeToIPFS(reader io.Reader, args ...string) *RunResult { return n.Runner.Run(RunRequest{ Path: n.IPFSBin, Args: args, @@ -153,7 +153,7 @@ func (n *Node) RunPipeToIPFS(reader io.Reader, args ...string) RunResult { }) } -func (n *Node) RunIPFS(args ...string) RunResult { +func (n *Node) RunIPFS(args ...string) *RunResult { return n.Runner.Run(RunRequest{ Path: n.IPFSBin, Args: args, @@ -216,7 +216,7 @@ func (n *Node) StartDaemon(ipfsArgs ...string) *Node { RunFunc: (*exec.Cmd).Start, }) - n.Daemon = &res + n.Daemon = res log.Debugf("node %d started, checking API", n.ID) n.WaitOnAPI() @@ -399,8 +399,6 @@ func (n *Node) SwarmAddrs() []multiaddr.Multiaddr { Path: n.IPFSBin, Args: []string{"swarm", "addrs", "local"}, }) - ipfsProtocol := multiaddr.ProtocolWithCode(multiaddr.P_IPFS).Name - peerID := n.PeerID() out := strings.TrimSpace(res.Stdout.String()) outLines := strings.Split(out, "\n") var addrs []multiaddr.Multiaddr @@ -409,9 +407,18 @@ func (n *Node) SwarmAddrs() []multiaddr.Multiaddr { if err != nil { panic(err) } + addrs = append(addrs, ma) + } + return addrs +} +func (n *Node) SwarmAddrsWithPeerIDs() []multiaddr.Multiaddr { + ipfsProtocol := multiaddr.ProtocolWithCode(multiaddr.P_IPFS).Name + peerID := n.PeerID() + var addrs []multiaddr.Multiaddr + for _, ma := range n.SwarmAddrs() { // add the peer ID to the multiaddr if it doesn't have it - _, err = ma.ValueForProtocol(multiaddr.P_IPFS) + _, err := ma.ValueForProtocol(multiaddr.P_IPFS) if errors.Is(err, multiaddr.ErrProtocolNotFound) { comp, err := multiaddr.NewComponent(ipfsProtocol, peerID.String()) if err != nil { @@ -424,10 +431,27 @@ func (n *Node) SwarmAddrs() []multiaddr.Multiaddr { return addrs } +func (n *Node) SwarmAddrsWithoutPeerIDs() []multiaddr.Multiaddr { + var addrs []multiaddr.Multiaddr + for _, ma := range n.SwarmAddrs() { + var components []multiaddr.Multiaddr + multiaddr.ForEach(ma, func(c multiaddr.Component) bool { + if c.Protocol().Code == multiaddr.P_IPFS { + return true + } + components = append(components, &c) + return true + }) + ma = multiaddr.Join(components...) + addrs = append(addrs, ma) + } + return addrs +} + func (n *Node) Connect(other *Node) *Node { n.Runner.MustRun(RunRequest{ Path: n.IPFSBin, - Args: []string{"swarm", "connect", other.SwarmAddrs()[0].String()}, + Args: []string{"swarm", "connect", other.SwarmAddrsWithPeerIDs()[0].String()}, }) return n } diff --git a/test/cli/harness/nodes.go b/test/cli/harness/nodes.go index dbc7de16ba1..872d7767913 100644 --- a/test/cli/harness/nodes.go +++ b/test/cli/harness/nodes.go @@ -4,6 +4,7 @@ import ( "sync" "github.com/multiformats/go-multiaddr" + "golang.org/x/sync/errgroup" ) // Nodes is a collection of Kubo nodes along with operations on groups of nodes. @@ -16,6 +17,21 @@ func (n Nodes) Init(args ...string) Nodes { return n } +func (n Nodes) ForEachPar(f func(*Node)) { + group := &errgroup.Group{} + for _, node := range n { + node := node + group.Go(func() error { + f(node) + return nil + }) + } + err := group.Wait() + if err != nil { + panic(err) + } +} + func (n Nodes) Connect() Nodes { wg := sync.WaitGroup{} for i, node := range n { diff --git a/test/cli/harness/run.go b/test/cli/harness/run.go index 9cbb871bc10..c2a3662be8b 100644 --- a/test/cli/harness/run.go +++ b/test/cli/harness/run.go @@ -51,7 +51,7 @@ func environToMap(environ []string) map[string]string { return m } -func (r *Runner) Run(req RunRequest) RunResult { +func (r *Runner) Run(req RunRequest) *RunResult { cmd := exec.Command(req.Path, req.Args...) stdout := &Buffer{} stderr := &Buffer{} @@ -86,17 +86,17 @@ func (r *Runner) Run(req RunRequest) RunResult { result.ExitErr = exitErr } - return result + return &result } // MustRun runs the command and fails the test if the command fails. -func (r *Runner) MustRun(req RunRequest) RunResult { +func (r *Runner) MustRun(req RunRequest) *RunResult { result := r.Run(req) r.AssertNoError(result) return result } -func (r *Runner) AssertNoError(result RunResult) { +func (r *Runner) AssertNoError(result *RunResult) { if result.ExitErr != nil { log.Panicf("'%s' returned error, code: %d, err: %s\nstdout:%s\nstderr:%s\n", result.Cmd.Args, result.ExitErr.ExitCode(), result.ExitErr.Error(), result.Stdout.String(), result.Stderr.String()) diff --git a/test/sharness/t0170-legacy-dht.sh b/test/sharness/t0170-legacy-dht.sh deleted file mode 100755 index fc11b9044dd..00000000000 --- a/test/sharness/t0170-legacy-dht.sh +++ /dev/null @@ -1,121 +0,0 @@ -#!/usr/bin/env bash - -# Legacy / deprecated, see: t0170-routing-dht.sh -test_description="Test dht command" - -. lib/test-lib.sh - -test_dht() { - NUM_NODES=5 - - test_expect_success 'init iptb' ' - rm -rf .iptb/ && - iptb testbed create -type localipfs -count $NUM_NODES -init - ' - - test_expect_success 'DHT-only routing' ' - iptb run -- ipfs config Routing.Type dht - ' - - startup_cluster $NUM_NODES $@ - - test_expect_success 'peer ids' ' - PEERID_0=$(iptb attr get 0 id) && - PEERID_2=$(iptb attr get 2 id) - ' - - # ipfs dht findpeer - test_expect_success 'findpeer' ' - ipfsi 1 dht findpeer $PEERID_0 | sort >actual && - ipfsi 0 id -f "" | cut -d / -f 1-5 | sort >expected && - test_cmp actual expected - ' - - # ipfs dht get - test_expect_success 'get with good keys works' ' - HASH="$(echo "hello world" | ipfsi 2 add -q)" && - ipfsi 2 name publish "/ipfs/$HASH" && - ipfsi 1 dht get "/ipns/$PEERID_2" >get_result - ' - - test_expect_success 'get with good keys contains the right value' ' - cat get_result | grep -aq "/ipfs/$HASH" - ' - - test_expect_success 'put round trips (#3124)' ' - ipfsi 0 dht put "/ipns/$PEERID_2" get_result | sort >putted && - [ -s putted ] || - test_fsh cat putted - ' - - test_expect_success 'put with bad keys fails (issue #5113)' ' - ipfsi 0 dht put "foo" <<putted - ipfsi 0 dht put "/pk/foo" <<>putted - ipfsi 0 dht put "/ipns/foo" <<>putted - [ ! -s putted ] || - test_fsh cat putted - ' - - test_expect_success 'put with bad keys returns error (issue #4611)' ' - test_must_fail ipfsi 0 dht put "foo" << afile && - HASH=$(ipfsi 3 add -q afile) - ' - - # ipfs dht findprovs - test_expect_success 'findprovs' ' - ipfsi 4 dht findprovs $HASH > provs && - iptb attr get 3 id > expected && - test_cmp provs expected - ' - - - # ipfs dht query - # - # We test all nodes. 4 nodes should see the same peer ID, one node (the - # closest) should see a different one. - - for i in $(test_seq 0 4); do - test_expect_success "query from $i" ' - ipfsi "$i" dht query "$HASH" | head -1 >closest-$i - ' - done - - test_expect_success "collecting results" ' - cat closest-* | sort | uniq -c | sed -e "s/ *\([0-9]\+\) .*/\1/g" | sort -g > actual && - echo 1 > expected && - echo 4 >> expected - ' - - test_expect_success "checking results" ' - test_cmp actual expected - ' - - test_expect_success 'stop iptb' ' - iptb stop - ' - - test_expect_success "dht commands fail when offline" ' - test_must_fail ipfsi 0 dht findprovs "$HASH" 2>err_findprovs && - test_must_fail ipfsi 0 dht findpeer "$HASH" 2>err_findpeer && - test_must_fail ipfsi 0 dht put "/ipns/$PEERID_2" "get_result" 2>err_put && - test_should_contain "this command must be run in online mode" err_findprovs && - test_should_contain "this command must be run in online mode" err_findpeer && - test_should_contain "this action must be run in online mode" err_put - ' -} - -test_dht -test_dht --enable-pubsub-experiment --enable-namesys-pubsub - -test_done From fdbe363eb167a3a6e4800cd277dc7e8414bca86a Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Wed, 8 Mar 2023 16:25:45 -0500 Subject: [PATCH 45/93] test: parallelize more of rcmgr Go tests --- test/cli/harness/node.go | 8 ---- test/cli/rcmgr_test.go | 82 ++++++++++++++++++++++++---------------- 2 files changed, 50 insertions(+), 40 deletions(-) diff --git a/test/cli/harness/node.go b/test/cli/harness/node.go index 181fca99bc4..cc251e11b0f 100644 --- a/test/cli/harness/node.go +++ b/test/cli/harness/node.go @@ -121,14 +121,6 @@ func (n *Node) UpdateUserSuppliedResourceManagerOverrides(f func(overrides *rcmg n.WriteUserSuppliedResourceOverrides(overrides) } -func (n *Node) UpdateConfigAndUserSuppliedResourceManagerOverrides(f func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig)) { - overrides := n.ReadUserResourceOverrides() - cfg := n.ReadConfig() - f(cfg, overrides) - n.WriteConfig(cfg) - n.WriteUserSuppliedResourceOverrides(overrides) -} - func (n *Node) IPFS(args ...string) *RunResult { res := n.RunIPFS(args...) n.Runner.AssertNoError(res) diff --git a/test/cli/rcmgr_test.go b/test/cli/rcmgr_test.go index fb644e1a746..51b2b0452e3 100644 --- a/test/cli/rcmgr_test.go +++ b/test/cli/rcmgr_test.go @@ -49,6 +49,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("Very high connmgr highwater", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() node.UpdateConfig(func(cfg *config.Config) { cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(1000) @@ -74,6 +75,7 @@ func TestRcmgr(t *testing.T) { node.StartDaemon() t.Run("conns and streams are above 800 for default connmgr settings", func(t *testing.T) { + t.Parallel() res := node.RunIPFS("swarm", "resources", "--enc=json") require.Equal(t, 0, res.ExitCode()) limits := unmarshalLimits(t, res.Stdout.Bytes()) @@ -87,6 +89,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("limits should succeed", func(t *testing.T) { + t.Parallel() res := node.RunIPFS("swarm", "resources", "--enc=json") assert.Equal(t, 0, res.ExitCode()) @@ -106,6 +109,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("swarm stats works", func(t *testing.T) { + t.Parallel() res := node.RunIPFS("swarm", "resources", "--enc=json") require.Equal(t, 0, res.ExitCode()) @@ -123,6 +127,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("smoke test transient scope", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { overrides.Transient.Memory = 88888 @@ -135,6 +140,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("smoke test service scope", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { overrides.Service = map[string]rcmgr.ResourceLimits{"foo": {Memory: 77777}} @@ -147,6 +153,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("smoke test protocol scope", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { overrides.Protocol = map[protocol.ID]rcmgr.ResourceLimits{"foo": {Memory: 66666}} @@ -159,6 +166,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("smoke test peer scope", func(t *testing.T) { + t.Parallel() validPeerID, err := peer.Decode("QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN") assert.NoError(t, err) node := harness.NewT(t).NewNode().Init() @@ -172,13 +180,17 @@ func TestRcmgr(t *testing.T) { assert.Equal(t, rcmgr.LimitVal64(55555), limits.Peers[validPeerID].Memory) }) - t.Run("", func(t *testing.T) { + t.Run("blocking and allowlists", func(t *testing.T) { + t.Parallel() nodes := harness.NewT(t).NewNodes(3).Init() node0, node1, node2 := nodes[0], nodes[1], nodes[2] - // peerID0, peerID1, peerID2 := node0.PeerID(), node1.PeerID(), node2.PeerID() peerID1, peerID2 := node1.PeerID().String(), node2.PeerID().String() - node0.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + node0.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ResourceMgr.Enabled = config.True + cfg.Swarm.ResourceMgr.Allowlist = []string{"/ip4/0.0.0.0/ipcidr/0/p2p/" + peerID2} + }) + node0.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { *overrides = rcmgr.PartialLimitConfig{ System: rcmgr.ResourceLimits{ Conns: rcmgr.BlockAllLimit, @@ -186,91 +198,97 @@ func TestRcmgr(t *testing.T) { ConnsOutbound: rcmgr.BlockAllLimit, }, } - cfg.Swarm.ResourceMgr.Enabled = config.True - cfg.Swarm.ResourceMgr.Allowlist = []string{"/ip4/0.0.0.0/ipcidr/0/p2p/" + peerID2} }) nodes.StartDaemons() - t.Parallel() - t.Run("node 0 should fail to connect to node 1", func(t *testing.T) { + t.Run("node 0 should fail to connect to and ping node 1", func(t *testing.T) { + t.Parallel() res := node0.Runner.Run(harness.RunRequest{ Path: node0.IPFSBin, - Args: []string{"swarm", "connect", node1.SwarmAddrs()[0].String()}, + Args: []string{"swarm", "connect", node1.SwarmAddrsWithPeerIDs()[0].String()}, }) assert.Equal(t, 1, res.ExitCode()) assert.Contains(t, res.Stderr.String(), "failed to find any peer in table") + + res = node0.RunIPFS("ping", "-n2", peerID1) + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "Error: ping failed") }) - t.Run("node 0 should connect to node 2 since it is allowlisted", func(t *testing.T) { + t.Run("node 0 should connect to and ping node 2 since it is allowlisted", func(t *testing.T) { + t.Parallel() res := node0.Runner.Run(harness.RunRequest{ Path: node0.IPFSBin, - Args: []string{"swarm", "connect", node2.SwarmAddrs()[0].String()}, + Args: []string{"swarm", "connect", node2.SwarmAddrsWithPeerIDs()[0].String()}, }) assert.Equal(t, 0, res.ExitCode()) - }) - t.Run("node 0 should fail to ping node 1", func(t *testing.T) { - res := node0.RunIPFS("ping", "-n2", peerID1) - assert.Equal(t, 1, res.ExitCode()) - assert.Contains(t, res.Stderr.String(), "Error: ping failed") - }) - - t.Run("node 0 should be able to ping node 2", func(t *testing.T) { - res := node0.RunIPFS("ping", "-n2", peerID2) + res = node0.RunIPFS("ping", "-n2", peerID2) assert.Equal(t, 0, res.ExitCode()) }) }) t.Run("daemon should refuse to start if connmgr.highwater < resources inbound", func(t *testing.T) { - t.Parallel() t.Run("system conns", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() - node.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) + cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) + }) + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { *overrides = rcmgr.PartialLimitConfig{ System: rcmgr.ResourceLimits{Conns: 128}, } - cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) - cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) }) res := node.RunIPFS("daemon") assert.Equal(t, 1, res.ExitCode()) }) t.Run("system conns inbound", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() - node.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) + cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) + }) + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { *overrides = rcmgr.PartialLimitConfig{ System: rcmgr.ResourceLimits{ConnsInbound: 128}, } - cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) - cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) }) res := node.RunIPFS("daemon") assert.Equal(t, 1, res.ExitCode()) }) t.Run("system streams", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() - node.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) + cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) + }) + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { *overrides = rcmgr.PartialLimitConfig{ System: rcmgr.ResourceLimits{Streams: 128}, } - cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) - cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) }) res := node.RunIPFS("daemon") assert.Equal(t, 1, res.ExitCode()) }) t.Run("system streams inbound", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() - node.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) + cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) + }) + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { *overrides = rcmgr.PartialLimitConfig{ System: rcmgr.ResourceLimits{StreamsInbound: 128}, } - cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) - cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) }) res := node.RunIPFS("daemon") From 0d94bac30c2060de3ffaab00954df20be3723e4b Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Wed, 8 Mar 2023 16:26:47 -0500 Subject: [PATCH 46/93] feat: add "autoclient" routing type This routing type is the same as "auto" but it creates the DHT in "client" mode and hence does not start a DHT server. --- cmd/ipfs/daemon.go | 61 ++++++++++++++----------- config/routing.go | 2 +- core/node/libp2p/routingopt.go | 5 +- docs/changelogs/v0.19.md | 6 +++ docs/config.md | 6 ++- test/cli/delegated_routing_http_test.go | 2 +- test/cli/dht_autoclient_test.go | 39 ++++++++++++++++ 7 files changed, 88 insertions(+), 33 deletions(-) create mode 100644 test/cli/dht_autoclient_test.go diff --git a/cmd/ipfs/daemon.go b/cmd/ipfs/daemon.go index 21495c498fa..880d26b0e42 100644 --- a/cmd/ipfs/daemon.go +++ b/cmd/ipfs/daemon.go @@ -45,32 +45,33 @@ import ( ) const ( - adjustFDLimitKwd = "manage-fdlimit" - enableGCKwd = "enable-gc" - initOptionKwd = "init" - initConfigOptionKwd = "init-config" - initProfileOptionKwd = "init-profile" - ipfsMountKwd = "mount-ipfs" - ipnsMountKwd = "mount-ipns" - migrateKwd = "migrate" - mountKwd = "mount" - offlineKwd = "offline" // global option - routingOptionKwd = "routing" - routingOptionSupernodeKwd = "supernode" - routingOptionDHTClientKwd = "dhtclient" - routingOptionDHTKwd = "dht" - routingOptionDHTServerKwd = "dhtserver" - routingOptionNoneKwd = "none" - routingOptionCustomKwd = "custom" - routingOptionDefaultKwd = "default" - routingOptionAutoKwd = "auto" - unencryptTransportKwd = "disable-transport-encryption" - unrestrictedAPIAccessKwd = "unrestricted-api" - writableKwd = "writable" - enablePubSubKwd = "enable-pubsub-experiment" - enableIPNSPubSubKwd = "enable-namesys-pubsub" - enableMultiplexKwd = "enable-mplex-experiment" - agentVersionSuffix = "agent-version-suffix" + adjustFDLimitKwd = "manage-fdlimit" + enableGCKwd = "enable-gc" + initOptionKwd = "init" + initConfigOptionKwd = "init-config" + initProfileOptionKwd = "init-profile" + ipfsMountKwd = "mount-ipfs" + ipnsMountKwd = "mount-ipns" + migrateKwd = "migrate" + mountKwd = "mount" + offlineKwd = "offline" // global option + routingOptionKwd = "routing" + routingOptionSupernodeKwd = "supernode" + routingOptionDHTClientKwd = "dhtclient" + routingOptionDHTKwd = "dht" + routingOptionDHTServerKwd = "dhtserver" + routingOptionNoneKwd = "none" + routingOptionCustomKwd = "custom" + routingOptionDefaultKwd = "default" + routingOptionAutoKwd = "auto" + routingOptionAutoClientKwd = "autoclient" + unencryptTransportKwd = "disable-transport-encryption" + unrestrictedAPIAccessKwd = "unrestricted-api" + writableKwd = "writable" + enablePubSubKwd = "enable-pubsub-experiment" + enableIPNSPubSubKwd = "enable-namesys-pubsub" + enableMultiplexKwd = "enable-mplex-experiment" + agentVersionSuffix = "agent-version-suffix" // apiAddrKwd = "address-api" // swarmAddrKwd = "address-swarm" ) @@ -416,6 +417,14 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment cfg.Identity.PeerID, cfg.Addresses.Swarm, cfg.Identity.PrivKey, + libp2p.DHTOption, + ) + case routingOptionAutoClientKwd: + ncfg.Routing = libp2p.ConstructDefaultRouting( + cfg.Identity.PeerID, + cfg.Addresses.Swarm, + cfg.Identity.PrivKey, + libp2p.DHTClientOption, ) case routingOptionDHTClientKwd: ncfg.Routing = libp2p.DHTClientOption diff --git a/config/routing.go b/config/routing.go index f19414ff308..1210bb3cecc 100644 --- a/config/routing.go +++ b/config/routing.go @@ -10,7 +10,7 @@ import ( type Routing struct { // Type sets default daemon routing mode. // - // Can be one of "auto", "dht", "dhtclient", "dhtserver", "none", or "custom". + // Can be one of "auto", "autoclient", "dht", "dhtclient", "dhtserver", "none", or "custom". // When unset or set to "auto", DHT and implicit routers are used. // When "custom" is set, user-provided Routing.Routers is used. Type *OptionalString `json:",omitempty"` diff --git a/core/node/libp2p/routingopt.go b/core/node/libp2p/routingopt.go index bfb45971cc9..d54f37acc5c 100644 --- a/core/node/libp2p/routingopt.go +++ b/core/node/libp2p/routingopt.go @@ -40,7 +40,7 @@ func init() { } // ConstructDefaultRouting returns routers used when Routing.Type is unset or set to "auto" -func ConstructDefaultRouting(peerID string, addrs []string, privKey string) func( +func ConstructDefaultRouting(peerID string, addrs []string, privKey string, routingOpt RoutingOption) func( ctx context.Context, host host.Host, dstore datastore.Batching, @@ -58,8 +58,7 @@ func ConstructDefaultRouting(peerID string, addrs []string, privKey string) func // Different trade-offs can be made by setting Routing.Type = "custom" with own Routing.Routers var routers []*routinghelpers.ParallelRouter - // Run the default DHT routing (same as Routing.Type = "dht") - dhtRouting, err := DHTOption(ctx, host, dstore, validator, bootstrapPeers...) + dhtRouting, err := routingOpt(ctx, host, dstore, validator, bootstrapPeers...) if err != nil { return nil, err } diff --git a/docs/changelogs/v0.19.md b/docs/changelogs/v0.19.md index 7663308a6db..fede7a4547f 100644 --- a/docs/changelogs/v0.19.md +++ b/docs/changelogs/v0.19.md @@ -7,6 +7,7 @@ - [Overview](#overview) - [🔦 Highlights](#-highlights) - [Improving the libp2p resource management integration](#improving-the-libp2p-resource-management-integration) + - [Addition of "autoclient" router type](#addition-of-autoclient-router-type) - [📝 Changelog](#-changelog) - [👨‍👩‍👧‍👦 Contributors](#-contributors) @@ -22,6 +23,11 @@ and [0.18.1](https://github.com/ipfs/kubo/blob/master/docs/changelogs/v0.18.md#i - Note: we don't expect most users to need these capablities, but they are there if so. 1. [Doc updates](https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md). +#### Addition of "autoclient" router type +A new routing type "autoclient" has been added. This mode is similar to "auto", in that it is a hybrid of content routers (including Kademlia and HTTP routers), but it does not run a DHT server. This is similar to the difference between "dhtclient" and "dht" router types. + +See the [Routing.Type documentation](https://github.com/ipfs/kubo/blob/master/docs/config.md#routingtype) for more information. + ### 📝 Changelog ### 👨‍👩‍👧‍👦 Contributors diff --git a/docs/config.md b/docs/config.md index adf956ce01d..68666191802 100644 --- a/docs/config.md +++ b/docs/config.md @@ -1349,11 +1349,13 @@ Contains options for content, peer, and IPNS routing mechanisms. ### `Routing.Type` -There are multiple routing options: "auto", "none", "dht" and "custom". +There are multiple routing options: "auto", "autoclient", "none", "dht", "dhtclient", and "custom". * **DEFAULT:** If unset, or set to "auto", your node will use the IPFS DHT and parallel HTTP routers listed below for additional speed. +* If set to "autoclient", your node will behave as in "auto" but without running a DHT server. + * If set to "none", your node will use _no_ routing system. You'll have to explicitly connect to peers that have the content you're looking for. @@ -1379,7 +1381,7 @@ To force a specific DHT-only mode, client or server, set `Routing.Type` to `dhtclient` or `dhtserver` respectively. Please do not set this to `dhtserver` unless you're sure your node is reachable from the public network. -When `Routing.Type` is set to `auto` your node will accelerate some types of routing +When `Routing.Type` is set to `auto` or `autoclient` your node will accelerate some types of routing by leveraging HTTP endpoints compatible with [IPIP-337](https://github.com/ipfs/specs/pull/337) in addition to the IPFS DHT. By default, an instance of [IPNI](https://github.com/ipni/specs/blob/main/IPNI.md#readme) diff --git a/test/cli/delegated_routing_http_test.go b/test/cli/delegated_routing_http_test.go index 0b39a9b12e6..446ea515049 100644 --- a/test/cli/delegated_routing_http_test.go +++ b/test/cli/delegated_routing_http_test.go @@ -94,7 +94,7 @@ func TestHTTPDelegatedRouting(t *testing.T) { })) t.Cleanup(server.Close) - node.IPFS("config", "Routing.Type", "--json", `"custom"`) + node.IPFS("config", "Routing.Type", "custom") node.IPFS("config", "Routing.Routers.TestDelegatedRouter", "--json", ToJSONStr(JSONObj{ "Type": "http", "Parameters": JSONObj{ diff --git a/test/cli/dht_autoclient_test.go b/test/cli/dht_autoclient_test.go new file mode 100644 index 00000000000..749e34b348e --- /dev/null +++ b/test/cli/dht_autoclient_test.go @@ -0,0 +1,39 @@ +package cli + +import ( + "bytes" + "testing" + + "github.com/ipfs/kubo/test/cli/harness" + "github.com/ipfs/kubo/test/cli/testutils" + "github.com/stretchr/testify/assert" +) + +func TestDHTAutoclient(t *testing.T) { + t.Parallel() + nodes := harness.NewT(t).NewNodes(10).Init() + harness.Nodes(nodes[8:]).ForEachPar(func(node *harness.Node) { + node.IPFS("config", "Routing.Type", "autoclient") + }) + nodes.StartDaemons().Connect() + + t.Run("file added on node in client mode is retrievable from node in client mode", func(t *testing.T) { + t.Parallel() + randomBytes := testutils.RandomBytes(1000) + hash := nodes[8].IPFSAdd(bytes.NewReader(randomBytes)) + + res := nodes[9].IPFS("cat", hash) + assert.Equal(t, randomBytes, []byte(res.Stdout.Trimmed())) + }) + + t.Run("file added on node in server mode is retrievable from all nodes", func(t *testing.T) { + t.Parallel() + randomBytes := testutils.RandomBytes(1000) + hash := nodes[0].IPFSAdd(bytes.NewReader(randomBytes)) + + for i := 0; i < 10; i++ { + res := nodes[i].IPFS("cat", hash) + assert.Equal(t, randomBytes, []byte(res.Stdout.Trimmed())) + } + }) +} From a4052c645bce995cd88c93fc4fa1dbcf12c3f84c Mon Sep 17 00:00:00 2001 From: Marcin Rataj Date: Fri, 10 Mar 2023 15:30:18 +0100 Subject: [PATCH 47/93] chore: fix toc in changelog for 0.18 --- docs/changelogs/v0.18.md | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/docs/changelogs/v0.18.md b/docs/changelogs/v0.18.md index 5b3b154392d..f2a22d84eb7 100644 --- a/docs/changelogs/v0.18.md +++ b/docs/changelogs/v0.18.md @@ -88,22 +88,22 @@ Below is an outline of all that is in this release, so you get a sense of all th - - [Overview](#overview) - - [🔦 Highlights](#-highlights) - - [Content routing](#content-routing) - - [Default InterPlanetary Network Indexer](#default-interplanetary-network-indexer) - - [Increase provider record republish interval and expiration](#increase-provider-record-republish-interval-and-expiration) - - [Gateways](#gateways) - - [(DAG-)JSON and (DAG-)CBOR response formats](#dag-json-and-dag-cbor-response-formats) - - [🐎 Fast directory listings with DAG sizes](#-fast-directory-listings-with-dag-sizes) - - [QUIC and WebTransport](#quic-and-webtransport) - - [WebTransport enabled by default](#webtransport-enabled-by-default) - - [QUIC and WebTransport share a single port](#quic-and-webtransport-share-a-single-port) - - [Differentiating QUIC versions](#differentiating-quic-versions) - - [QUICv1 and WebTransport config migration](#quicv1-and-webtransport-config-migration) - - [Improving libp2p resource management integration](#improving-libp2p-resource-management-integration) - - [📝 Changelog](#-changelog) - - [👨‍👩‍👧‍👦 Contributors](#-contributors) +- [Overview](#overview) +- [🔦 Highlights](#-highlights) + - [Content routing](#content-routing) + - [Default InterPlanetary Network Indexer](#default-interplanetary-network-indexer) + - [Increase provider record republish interval and expiration](#increase-provider-record-republish-interval-and-expiration) + - [Gateways](#gateways) + - [(DAG-)JSON and (DAG-)CBOR response formats](#dag-json-and-dag-cbor-response-formats) + - [🐎 Fast directory listings with DAG sizes](#-fast-directory-listings-with-dag-sizes) + - [QUIC and WebTransport](#quic-and-webtransport) + - [WebTransport enabled by default](#webtransport-enabled-by-default) + - [QUIC and WebTransport share a single port](#quic-and-webtransport-share-a-single-port) + - [Differentiating QUIC versions](#differentiating-quic-versions) + - [QUICv1 and WebTransport config migration](#quicv1-and-webtransport-config-migration) + - [Improving libp2p resource management integration](#improving-libp2p-resource-management-integration) +- [📝 Changelog](#-changelog) +- [👨‍👩‍👧‍👦 Contributors](#-contributors) From fc81639af441cb78b28ca78c6886ba0dd8c5db04 Mon Sep 17 00:00:00 2001 From: Laurent Senta Date: Thu, 9 Mar 2023 15:21:50 +0100 Subject: [PATCH 48/93] test: name --verify forgets the verified key --- test/sharness/t0100-name.sh | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/test/sharness/t0100-name.sh b/test/sharness/t0100-name.sh index 44c2afb2d69..34f33ea4d89 100755 --- a/test/sharness/t0100-name.sh +++ b/test/sharness/t0100-name.sh @@ -314,4 +314,32 @@ test_name_with_key 'rsa' test_name_with_key 'ed25519_b58' test_name_with_key 'ed25519_b36' + +# `ipfs name inspect --verify` using the wrong RSA key should not succeed + +test_init_ipfs +test_launch_ipfs_daemon + +test_expect_success "prepare RSA keys" ' + export KEY_1=`ipfs key gen --type=rsa --size=4096 key1` && + export KEY_2=`ipfs key gen --type=rsa --size=4096 key2` && + export PEERID_1=`ipfs key list --ipns-base=base36 -l | grep key1 | cut -d " " -f1` && + export PEERID_2=`ipfs key list --ipns-base=base36 -l | grep key2 | cut -d " " -f1` +' + +test_expect_success "ipfs name publish --allow-offline --key= ' succeeds" ' + ipfs name publish --allow-offline --key=${KEY_1} "/ipfs/$( echo "helloworld" | ipfs add --inline -q )" && + ipfs routing get "/ipns/$PEERID_1" > ipns_record +' + +test_expect_success "ipfs name inspect --verify' has '.Validation.Validity' set to 'true' with correct Peer ID" ' + ipfs name inspect --verify $PEERID_1 --enc json < ipns_record | jq -e ".Validation.Valid == true" +' + +test_expect_success "ipfs name inspect --verify' has '.Validation.Validity' set to 'false' when we verify the wrong Peer ID" ' + ipfs name inspect --verify $PEERID_2 --enc json < ipns_record | jq -e ".Validation.Valid == false" +' + +test_kill_ipfs_daemon + test_done From 877d091d7530e6ffea33c55c956077e06bc89557 Mon Sep 17 00:00:00 2001 From: Laurent Senta Date: Thu, 9 Mar 2023 15:23:52 +0100 Subject: [PATCH 49/93] fix: --verify forgets the verified key --- core/commands/name/name.go | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/core/commands/name/name.go b/core/commands/name/name.go index 7999aee3ddc..0e4fa6cb548 100644 --- a/core/commands/name/name.go +++ b/core/commands/name/name.go @@ -222,6 +222,20 @@ Passing --verify will verify signature against provided public key. // Peer ID. if len(entry.PubKey) > 0 { pub, err = ic.UnmarshalPublicKey(entry.PubKey) + if err != nil { + return err + } + + // Verify the public key matches the name we are verifying. + entryID, err := peer.IDFromPublicKey(pub) + + if err != nil { + return err + } + + if id != entryID { + return fmt.Errorf("record public key does not match the verified name") + } } } if err != nil { From 7f7a5ab1b9c3229b3ab52429a7581a9ed196f44e Mon Sep 17 00:00:00 2001 From: Eng Zer Jun Date: Wed, 10 Aug 2022 22:04:19 +0800 Subject: [PATCH 50/93] test: use `T.TempDir` to create temporary test directory This commit replaces `os.MkdirTemp` with `t.TempDir` in tests. The directory created by `t.TempDir` is automatically removed when the test and all its subtests complete. Prior to this commit, temporary directory created using `os.MkdirTemp` needs to be removed manually by calling `os.RemoveAll`, which is omitted in some tests. The error handling boilerplate e.g. defer func() { if err := os.RemoveAll(dir); err != nil { t.Fatal(err) } } is also tedious, but `t.TempDir` handles this for us nicely. Reference: https://pkg.go.dev/testing#T.TempDir Signed-off-by: Eng Zer Jun --- fuse/node/mount_test.go | 10 +++------- repo/fsrepo/config_test.go | 25 ++++--------------------- repo/fsrepo/fsrepo_test.go | 21 ++++++--------------- test/bench/bench_cli_ipfs_add/main.go | 7 +------ test/bench/offline_add/main.go | 6 +----- 5 files changed, 15 insertions(+), 54 deletions(-) diff --git a/fuse/node/mount_test.go b/fuse/node/mount_test.go index 12313ae3ea6..1691cfa5ba2 100644 --- a/fuse/node/mount_test.go +++ b/fuse/node/mount_test.go @@ -4,6 +4,7 @@ package node import ( + "context" "os" "strings" "testing" @@ -11,8 +12,6 @@ import ( "bazil.org/fuse" - "context" - core "github.com/ipfs/kubo/core" ipns "github.com/ipfs/kubo/fuse/ipns" mount "github.com/ipfs/kubo/fuse/mount" @@ -52,11 +51,8 @@ func TestExternalUnmount(t *testing.T) { t.Fatal(err) } - // get the test dir paths (/tmp/fusetestXXXX) - dir, err := os.MkdirTemp("", "fusetest") - if err != nil { - t.Fatal(err) - } + // get the test dir paths (/tmp/TestExternalUnmount) + dir := t.TempDir() ipfsDir := dir + "/ipfs" ipnsDir := dir + "/ipns" diff --git a/repo/fsrepo/config_test.go b/repo/fsrepo/config_test.go index 03af75a9631..060d0222ada 100644 --- a/repo/fsrepo/config_test.go +++ b/repo/fsrepo/config_test.go @@ -2,7 +2,6 @@ package fsrepo_test import ( "encoding/json" - "os" "reflect" "testing" @@ -88,11 +87,7 @@ func TestDefaultDatastoreConfig(t *testing.T) { t.Fatal(err) } - dir, err := os.MkdirTemp("", "ipfs-datastore-config-test") - if err != nil { - t.Fatal(err) - } - defer os.RemoveAll(dir) // clean up + dir := t.TempDir() config := new(config.Datastore) err = json.Unmarshal(defaultConfig, config) @@ -126,11 +121,7 @@ func TestLevelDbConfig(t *testing.T) { if err != nil { t.Fatal(err) } - dir, err := os.MkdirTemp("", "ipfs-datastore-config-test") - if err != nil { - t.Fatal(err) - } - defer os.RemoveAll(dir) // clean up + dir := t.TempDir() spec := make(map[string]interface{}) err = json.Unmarshal(leveldbConfig, &spec) @@ -164,11 +155,7 @@ func TestFlatfsConfig(t *testing.T) { if err != nil { t.Fatal(err) } - dir, err := os.MkdirTemp("", "ipfs-datastore-config-test") - if err != nil { - t.Fatal(err) - } - defer os.RemoveAll(dir) // clean up + dir := t.TempDir() spec := make(map[string]interface{}) err = json.Unmarshal(flatfsConfig, &spec) @@ -202,11 +189,7 @@ func TestMeasureConfig(t *testing.T) { if err != nil { t.Fatal(err) } - dir, err := os.MkdirTemp("", "ipfs-datastore-config-test") - if err != nil { - t.Fatal(err) - } - defer os.RemoveAll(dir) // clean up + dir := t.TempDir() spec := make(map[string]interface{}) err = json.Unmarshal(measureConfig, &spec) diff --git a/repo/fsrepo/fsrepo_test.go b/repo/fsrepo/fsrepo_test.go index 7c7551d205d..6b30b107adb 100644 --- a/repo/fsrepo/fsrepo_test.go +++ b/repo/fsrepo/fsrepo_test.go @@ -13,18 +13,9 @@ import ( config "github.com/ipfs/kubo/config" ) -// swap arg order -func testRepoPath(p string, t *testing.T) string { - name, err := os.MkdirTemp("", p) - if err != nil { - t.Fatal(err) - } - return name -} - func TestInitIdempotence(t *testing.T) { t.Parallel() - path := testRepoPath("", t) + path := t.TempDir() for i := 0; i < 10; i++ { assert.Nil(Init(path, &config.Config{Datastore: config.DefaultDatastoreConfig()}), t, "multiple calls to init should succeed") } @@ -37,8 +28,8 @@ func Remove(repoPath string) error { func TestCanManageReposIndependently(t *testing.T) { t.Parallel() - pathA := testRepoPath("a", t) - pathB := testRepoPath("b", t) + pathA := t.TempDir() + pathB := t.TempDir() t.Log("initialize two repos") assert.Nil(Init(pathA, &config.Config{Datastore: config.DefaultDatastoreConfig()}), t, "a", "should initialize successfully") @@ -65,7 +56,7 @@ func TestCanManageReposIndependently(t *testing.T) { func TestDatastoreGetNotAllowedAfterClose(t *testing.T) { t.Parallel() - path := testRepoPath("test", t) + path := t.TempDir() assert.True(!IsInitialized(path), t, "should NOT be initialized") assert.Nil(Init(path, &config.Config{Datastore: config.DefaultDatastoreConfig()}), t, "should initialize successfully") @@ -83,7 +74,7 @@ func TestDatastoreGetNotAllowedAfterClose(t *testing.T) { func TestDatastorePersistsFromRepoToRepo(t *testing.T) { t.Parallel() - path := testRepoPath("test", t) + path := t.TempDir() assert.Nil(Init(path, &config.Config{Datastore: config.DefaultDatastoreConfig()}), t) r1, err := Open(path) @@ -104,7 +95,7 @@ func TestDatastorePersistsFromRepoToRepo(t *testing.T) { func TestOpenMoreThanOnceInSameProcess(t *testing.T) { t.Parallel() - path := testRepoPath("", t) + path := t.TempDir() assert.Nil(Init(path, &config.Config{Datastore: config.DefaultDatastoreConfig()}), t) r1, err := Open(path) diff --git a/test/bench/bench_cli_ipfs_add/main.go b/test/bench/bench_cli_ipfs_add/main.go index a089410ef39..e7fe90e0407 100644 --- a/test/bench/bench_cli_ipfs_add/main.go +++ b/test/bench/bench_cli_ipfs_add/main.go @@ -45,12 +45,7 @@ func benchmarkAdd(amount int64) (*testing.BenchmarkResult, error) { b.SetBytes(amount) for i := 0; i < b.N; i++ { b.StopTimer() - tmpDir, err := os.MkdirTemp("", "") - if err != nil { - benchmarkError = err - b.Fatal(err) - } - defer os.RemoveAll(tmpDir) + tmpDir := b.TempDir() env := append( []string{fmt.Sprintf("%s=%s", config.EnvDir, path.Join(tmpDir, config.DefaultPathName))}, // first in order to override diff --git a/test/bench/offline_add/main.go b/test/bench/offline_add/main.go index a15ebcffda2..338a5f6ac24 100644 --- a/test/bench/offline_add/main.go +++ b/test/bench/offline_add/main.go @@ -37,11 +37,7 @@ func benchmarkAdd(amount int64) (*testing.BenchmarkResult, error) { b.SetBytes(amount) for i := 0; i < b.N; i++ { b.StopTimer() - tmpDir, err := os.MkdirTemp("", "") - if err != nil { - b.Fatal(err) - } - defer os.RemoveAll(tmpDir) + tmpDir := b.TempDir() env := append(os.Environ(), fmt.Sprintf("%s=%s", config.EnvDir, path.Join(tmpDir, config.DefaultPathName))) setupCmd := func(cmd *exec.Cmd) { From 676e557daf45f3b3244931f4568ce0582396db0c Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Fri, 16 Dec 2022 06:55:03 -0500 Subject: [PATCH 51/93] test: port peering test from sharness to Go This is the slowest test in the sharness test suite, because it has very long sleeps. It usually takes 2+ minutes to run. This new impl runs all peering tests in about 20 seconds, since it polls for conditions instead of sleeping, and runs the tests in parallel. This also has an additional test case for a peer that was never online and then connects. --- test/cli/harness/harness.go | 21 +++++ test/cli/harness/log.go | 155 +++++++++++++++++++++++++++++++++ test/cli/harness/node.go | 25 +++++- test/cli/harness/nodes.go | 20 +---- test/cli/peering_test.go | 141 ++++++++++++++++++++++++++++++ test/cli/testutils/strings.go | 14 +++ test/sharness/t0171-peering.sh | 127 --------------------------- 7 files changed, 358 insertions(+), 145 deletions(-) create mode 100644 test/cli/harness/log.go create mode 100644 test/cli/peering_test.go delete mode 100755 test/sharness/t0171-peering.sh diff --git a/test/cli/harness/harness.go b/test/cli/harness/harness.go index a35fead3512..e68116b5efc 100644 --- a/test/cli/harness/harness.go +++ b/test/cli/harness/harness.go @@ -11,6 +11,8 @@ import ( logging "github.com/ipfs/go-log/v2" . "github.com/ipfs/kubo/test/cli/testutils" + "github.com/libp2p/go-libp2p/core/peer" + "github.com/multiformats/go-multiaddr" ) // Harness tracks state for a test, such as temp dirs and IFPS nodes, and cleans them up after the test. @@ -188,3 +190,22 @@ func (h *Harness) Cleanup() { log.Panicf("removing temp dir %s: %s", h.Dir, err) } } + +// ExtractPeerID extracts a peer ID from the given multiaddr, and fatals if it does not contain a peer ID. +func (h *Harness) ExtractPeerID(m multiaddr.Multiaddr) peer.ID { + var peerIDStr string + multiaddr.ForEach(m, func(c multiaddr.Component) bool { + if c.Protocol().Code == multiaddr.P_P2P { + peerIDStr = c.Value() + } + return true + }) + if peerIDStr == "" { + panic(multiaddr.ErrProtocolNotFound) + } + peerID, err := peer.Decode(peerIDStr) + if err != nil { + panic(err) + } + return peerID +} diff --git a/test/cli/harness/log.go b/test/cli/harness/log.go new file mode 100644 index 00000000000..d76bb2747c1 --- /dev/null +++ b/test/cli/harness/log.go @@ -0,0 +1,155 @@ +package harness + +import ( + "fmt" + "path/filepath" + "runtime" + "sort" + "strings" + "sync" + "testing" + "time" +) + +type event struct { + timestamp time.Time + msg string +} + +type events []*event + +func (e events) Len() int { return len(e) } +func (e events) Less(i, j int) bool { return e[i].timestamp.Before(e[j].timestamp) } +func (e events) Swap(i, j int) { e[i], e[j] = e[j], e[i] } + +// TestLogger is a logger for tests. +// It buffers output and only writes the output if the test fails or output is explicitly turned on. +// The purpose of this logger is to allow Go test to run with the verbose flag without printing logs. +// The verbose flag is useful since it streams test progress, but also printing logs makes the output too verbose. +// +// You can also add prefixes that are prepended to each log message, for extra logging context. +// +// This is implemented as a hierarchy of loggers, with children flushing log entries back to parents. +// This works because t.Cleanup() processes entries in LIFO order, so children always flush first. +// +// Obviously this logger should never be used in production systems. +type TestLogger struct { + parent *TestLogger + children []*TestLogger + prefixes []string + prefixesIface []any + t *testing.T + buf events + m sync.Mutex + logsEnabled bool +} + +func NewTestLogger(t *testing.T) *TestLogger { + l := &TestLogger{t: t, buf: make(events, 0)} + t.Cleanup(l.flush) + return l +} + +func (t *TestLogger) buildPrefix(timestamp time.Time) string { + d := timestamp.Format("2006-01-02T15:04:05.999999") + _, file, lineno, _ := runtime.Caller(2) + file = filepath.Base(file) + caller := fmt.Sprintf("%s:%d", file, lineno) + + if len(t.prefixes) == 0 { + return fmt.Sprintf("%s\t%s\t", d, caller) + } + + prefixes := strings.Join(t.prefixes, ":") + return fmt.Sprintf("%s\t%s\t%s: ", d, caller, prefixes) +} + +func (t *TestLogger) Log(args ...any) { + timestamp := time.Now() + e := t.buildPrefix(timestamp) + fmt.Sprint(args...) + t.add(&event{timestamp: timestamp, msg: e}) +} + +func (t *TestLogger) Logf(format string, args ...any) { + timestamp := time.Now() + e := t.buildPrefix(timestamp) + fmt.Sprintf(format, args...) + t.add(&event{timestamp: timestamp, msg: e}) +} + +func (t *TestLogger) Fatal(args ...any) { + timestamp := time.Now() + e := t.buildPrefix(timestamp) + fmt.Sprint(append([]any{"fatal: "}, args...)...) + t.add(&event{timestamp: timestamp, msg: e}) + t.t.FailNow() +} + +func (t *TestLogger) Fatalf(format string, args ...any) { + timestamp := time.Now() + e := t.buildPrefix(timestamp) + fmt.Sprintf(fmt.Sprintf("fatal: %s", format), args...) + t.add(&event{timestamp: timestamp, msg: e}) + t.t.FailNow() +} + +func (t *TestLogger) add(e *event) { + t.m.Lock() + defer t.m.Unlock() + t.buf = append(t.buf, e) +} + +func (t *TestLogger) AddPrefix(prefix string) *TestLogger { + l := &TestLogger{ + prefixes: append(t.prefixes, prefix), + prefixesIface: append(t.prefixesIface, prefix), + t: t.t, + parent: t, + logsEnabled: t.logsEnabled, + } + t.m.Lock() + defer t.m.Unlock() + + t.children = append(t.children, l) + t.t.Cleanup(l.flush) + + return l +} + +func (t *TestLogger) EnableLogs() { + t.m.Lock() + defer t.m.Unlock() + t.logsEnabled = true + if t.parent != nil { + if t.parent.logsEnabled { + t.parent.EnableLogs() + } + } + fmt.Printf("enabling %d children\n", len(t.children)) + for _, c := range t.children { + if !c.logsEnabled { + c.EnableLogs() + } + } +} + +func (t *TestLogger) flush() { + if t.t.Failed() || t.logsEnabled { + t.m.Lock() + defer t.m.Unlock() + // if this is a child, send the events to the parent + // the root parent will print all the events in sorted order + if t.parent != nil { + for _, e := range t.buf { + t.parent.add(e) + } + } else { + // we're the root, sort all the events and then print them + sort.Sort(t.buf) + fmt.Println() + fmt.Printf("Logs for test %q:\n\n", t.t.Name()) + for _, e := range t.buf { + fmt.Println(e.msg) + } + fmt.Println() + } + t.buf = nil + } +} diff --git a/test/cli/harness/node.go b/test/cli/harness/node.go index cc251e11b0f..f740ab1b19f 100644 --- a/test/cli/harness/node.go +++ b/test/cli/harness/node.go @@ -453,9 +453,8 @@ func (n *Node) Peers() []multiaddr.Multiaddr { Path: n.IPFSBin, Args: []string{"swarm", "peers"}, }) - lines := strings.Split(strings.TrimSpace(res.Stdout.String()), "\n") var addrs []multiaddr.Multiaddr - for _, line := range lines { + for _, line := range res.Stdout.Lines() { ma, err := multiaddr.NewMultiaddr(line) if err != nil { panic(err) @@ -465,6 +464,28 @@ func (n *Node) Peers() []multiaddr.Multiaddr { return addrs } +func (n *Node) PeerWith(other *Node) { + n.UpdateConfig(func(cfg *config.Config) { + var addrs []multiaddr.Multiaddr + for _, addrStr := range other.ReadConfig().Addresses.Swarm { + ma, err := multiaddr.NewMultiaddr(addrStr) + if err != nil { + panic(err) + } + addrs = append(addrs, ma) + } + + cfg.Peering.Peers = append(cfg.Peering.Peers, peer.AddrInfo{ + ID: other.PeerID(), + Addrs: addrs, + }) + }) +} + +func (n *Node) Disconnect(other *Node) { + n.IPFS("swarm", "disconnect", "/p2p/"+other.PeerID().String()) +} + // GatewayURL waits for the gateway file and then returns its contents or times out. func (n *Node) GatewayURL() string { timer := time.NewTimer(1 * time.Second) diff --git a/test/cli/harness/nodes.go b/test/cli/harness/nodes.go index 872d7767913..78662afbbea 100644 --- a/test/cli/harness/nodes.go +++ b/test/cli/harness/nodes.go @@ -3,6 +3,7 @@ package harness import ( "sync" + . "github.com/ipfs/kubo/test/cli/testutils" "github.com/multiformats/go-multiaddr" "golang.org/x/sync/errgroup" ) @@ -11,9 +12,7 @@ import ( type Nodes []*Node func (n Nodes) Init(args ...string) Nodes { - for _, node := range n { - node.Init() - } + ForEachPar(n, func(node *Node) { node.Init(args...) }) return n } @@ -59,22 +58,11 @@ func (n Nodes) Connect() Nodes { } func (n Nodes) StartDaemons() Nodes { - wg := sync.WaitGroup{} - for _, node := range n { - wg.Add(1) - node := node - go func() { - defer wg.Done() - node.StartDaemon() - }() - } - wg.Wait() + ForEachPar(n, func(node *Node) { node.StartDaemon() }) return n } func (n Nodes) StopDaemons() Nodes { - for _, node := range n { - node.StopDaemon() - } + ForEachPar(n, func(node *Node) { node.StopDaemon() }) return n } diff --git a/test/cli/peering_test.go b/test/cli/peering_test.go new file mode 100644 index 00000000000..f3e797fae80 --- /dev/null +++ b/test/cli/peering_test.go @@ -0,0 +1,141 @@ +package cli + +import ( + "fmt" + "math/rand" + "testing" + "time" + + "github.com/ipfs/kubo/config" + "github.com/ipfs/kubo/test/cli/harness" + . "github.com/ipfs/kubo/test/cli/testutils" + "github.com/libp2p/go-libp2p/core/peer" + "github.com/stretchr/testify/assert" +) + +func TestPeering(t *testing.T) { + t.Parallel() + + type peering struct { + from int + to int + } + + newRandPort := func() int { + n := rand.Int() + return 3000 + (n % 1000) + } + + containsPeerID := func(p peer.ID, peers []peer.ID) bool { + for _, peerID := range peers { + if p == peerID { + return true + } + } + return false + } + + assertPeered := func(h *harness.Harness, from *harness.Node, to *harness.Node) { + assert.Eventuallyf(t, func() bool { + fromPeers := from.Peers() + if len(fromPeers) == 0 { + return false + } + var fromPeerIDs []peer.ID + for _, p := range fromPeers { + fromPeerIDs = append(fromPeerIDs, h.ExtractPeerID(p)) + } + return containsPeerID(to.PeerID(), fromPeerIDs) + }, 20*time.Second, 10*time.Millisecond, "%d -> %d not peered", from.ID, to.ID) + } + + assertNotPeered := func(h *harness.Harness, from *harness.Node, to *harness.Node) { + assert.Eventuallyf(t, func() bool { + fromPeers := from.Peers() + if len(fromPeers) == 0 { + return false + } + var fromPeerIDs []peer.ID + for _, p := range fromPeers { + fromPeerIDs = append(fromPeerIDs, h.ExtractPeerID(p)) + } + return !containsPeerID(to.PeerID(), fromPeerIDs) + }, 20*time.Second, 10*time.Millisecond, "%d -> %d peered", from.ID, to.ID) + } + + assertPeerings := func(h *harness.Harness, nodes []*harness.Node, peerings []peering) { + ForEachPar(peerings, func(peering peering) { + assertPeered(h, nodes[peering.from], nodes[peering.to]) + }) + } + + createNodes := func(t *testing.T, n int, peerings []peering) (*harness.Harness, harness.Nodes) { + h := harness.NewT(t) + nodes := h.NewNodes(n).Init() + nodes.ForEachPar(func(node *harness.Node) { + node.UpdateConfig(func(cfg *config.Config) { + cfg.Routing.Type = config.NewOptionalString("none") + cfg.Addresses.Swarm = []string{fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", newRandPort())} + }) + + }) + + for _, peering := range peerings { + nodes[peering.from].PeerWith(nodes[peering.to]) + } + + return h, nodes + } + + t.Run("bidirectional peering should work (simultaneous connect)", func(t *testing.T) { + t.Parallel() + peerings := []peering{{from: 0, to: 1}, {from: 1, to: 0}, {from: 1, to: 2}} + h, nodes := createNodes(t, 3, peerings) + + nodes.StartDaemons() + assertPeerings(h, nodes, peerings) + + nodes[0].Disconnect(nodes[1]) + assertPeerings(h, nodes, peerings) + }) + + t.Run("1 should reconnect to 2 when 2 disconnects from 1", func(t *testing.T) { + t.Parallel() + peerings := []peering{{from: 0, to: 1}, {from: 1, to: 0}, {from: 1, to: 2}} + h, nodes := createNodes(t, 3, peerings) + + nodes.StartDaemons() + assertPeerings(h, nodes, peerings) + + nodes[2].Disconnect(nodes[1]) + assertPeerings(h, nodes, peerings) + }) + + t.Run("1 will peer with 2 when it comes online", func(t *testing.T) { + t.Parallel() + peerings := []peering{{from: 0, to: 1}, {from: 1, to: 0}, {from: 1, to: 2}} + h, nodes := createNodes(t, 3, peerings) + + nodes[0].StartDaemon() + nodes[1].StartDaemon() + assertPeerings(h, nodes, []peering{{from: 0, to: 1}, {from: 1, to: 0}}) + + nodes[2].StartDaemon() + assertPeerings(h, nodes, peerings) + }) + + t.Run("1 will re-peer with 2 when it disconnects and then comes back online", func(t *testing.T) { + t.Parallel() + peerings := []peering{{from: 0, to: 1}, {from: 1, to: 0}, {from: 1, to: 2}} + h, nodes := createNodes(t, 3, peerings) + + nodes.StartDaemons() + assertPeerings(h, nodes, peerings) + + nodes[2].StopDaemon() + assertNotPeered(h, nodes[1], nodes[2]) + + nodes[2].StartDaemon() + assertPeerings(h, nodes, peerings) + }) +} diff --git a/test/cli/testutils/strings.go b/test/cli/testutils/strings.go index 1fb1512485e..110051e679f 100644 --- a/test/cli/testutils/strings.go +++ b/test/cli/testutils/strings.go @@ -7,6 +7,7 @@ import ( "net/netip" "net/url" "strings" + "sync" "github.com/multiformats/go-multiaddr" manet "github.com/multiformats/go-multiaddr/net" @@ -75,3 +76,16 @@ func URLStrToMultiaddr(u string) multiaddr.Multiaddr { } return ma } + +// ForEachPar invokes f in a new goroutine for each element of s and waits for all to complete. +func ForEachPar[T any](s []T, f func(T)) { + wg := sync.WaitGroup{} + wg.Add(len(s)) + for _, x := range s { + go func(x T) { + defer wg.Done() + f(x) + }(x) + } + wg.Wait() +} diff --git a/test/sharness/t0171-peering.sh b/test/sharness/t0171-peering.sh deleted file mode 100755 index 207b279803a..00000000000 --- a/test/sharness/t0171-peering.sh +++ /dev/null @@ -1,127 +0,0 @@ -#!/usr/bin/env bash - -test_description="Test peering service" - -. lib/test-lib.sh - -NUM_NODES=3 - -test_expect_success 'init iptb' ' - rm -rf .iptb/ && - iptb testbed create -type localipfs -count $NUM_NODES -init -' - -test_expect_success 'disabling routing' ' - iptb run -- ipfs config Routing.Type none -' - -for i in $(seq 0 2); do - ADDR="$(printf '["/ip4/127.0.0.1/tcp/%s"]' "$(( 3000 + ( RANDOM % 1000 ) ))")" - test_expect_success "configuring node $i to listen on $ADDR" ' - ipfsi "$i" config --json Addresses.Swarm "$ADDR" - ' -done - -peer_id() { - ipfsi "$1" config Identity.PeerID -} - -peer_addrs() { - ipfsi "$1" config Addresses.Swarm -} - -peer() { - PEER1="$1" && - PEER2="$2" && - PEER_LIST="$(ipfsi "$PEER1" config Peering.Peers || true)" && - { [[ "$PEER_LIST" == "null" ]] || PEER_LIST_INNER="${PEER_LIST:1:-1}"; } && - ADDR_INFO="$(printf '[%s{"ID": "%s", "Addrs": %s}]' \ - "${PEER_LIST_INNER:+${PEER_LIST_INNER},}" \ - "$(peer_id "$PEER2")" \ - "$(peer_addrs "$PEER2")")" && - ipfsi "$PEER1" config --json Peering.Peers "${ADDR_INFO}" -} - -# Peer: -# - 0 <-> 1 -# - 1 -> 2 -test_expect_success 'configure peering' ' - peer 0 1 && - peer 1 0 && - peer 1 2 -' - -list_peers() { - ipfsi "$1" swarm peers | sed 's|.*/p2p/\([^/]*\)$|\1|' | sort -u -} - -check_peers() { - sleep 20 # give it some time to settle. - test_expect_success 'verifying peering for peer 0' ' - list_peers 0 > peers_0_actual && - peer_id 1 > peers_0_expected && - test_cmp peers_0_expected peers_0_actual - ' - - test_expect_success 'verifying peering for peer 1' ' - list_peers 1 > peers_1_actual && - { peer_id 0 && peer_id 2 ; } | sort -u > peers_1_expected && - test_cmp peers_1_expected peers_1_actual - ' - - test_expect_success 'verifying peering for peer 2' ' - list_peers 2 > peers_2_actual && - peer_id 1 > peers_2_expected && - test_cmp peers_2_expected peers_2_actual - ' -} - -test_expect_success 'startup cluster' ' - iptb start -wait && - iptb run -- ipfs log level peering debug -' - -check_peers - -disconnect() { - ipfsi "$1" swarm disconnect "/p2p/$(peer_id "$2")" -} - -# Bidirectional peering shouldn't cause problems (e.g., simultaneous connect -# issues). -test_expect_success 'disconnecting 0->1' ' - disconnect 0 1 -' - -check_peers - -# 1 should reconnect to 2 when 2 disconnects from 1. -test_expect_success 'disconnecting 2->1' ' - disconnect 2 1 -' - -check_peers - -# 2 isn't peering. This test ensures that 1 will re-peer with 2 when it comes -# back online. -test_expect_success 'stopping 2' ' - iptb stop 2 -' - -# Wait to disconnect -sleep 30 - -test_expect_success 'starting 2' ' - iptb start 2 -' - -# Wait for backoff -sleep 30 - -check_peers - -test_expect_success "stop testbed" ' - iptb stop -' - -test_done From 92743b1bf5cb7185495b62c7e7d1b53845ae01c0 Mon Sep 17 00:00:00 2001 From: galargh Date: Sat, 11 Mar 2023 11:00:59 +0100 Subject: [PATCH 52/93] feat: publish html report and test summary from gotest --- .github/workflows/gotest.yml | 54 ++++++++++++++++++++++++++++++------ 1 file changed, 45 insertions(+), 9 deletions(-) diff --git a/.github/workflows/gotest.yml b/.github/workflows/gotest.yml index 8eb41a34dbd..e594b55ee27 100644 --- a/.github/workflows/gotest.yml +++ b/.github/workflows/gotest.yml @@ -23,22 +23,28 @@ jobs: run: shell: bash steps: - - uses: actions/setup-go@v3 + - name: Set up Go + uses: actions/setup-go@v3 with: go-version: 1.19.1 - - uses: actions/checkout@v3 - - uses: protocol/cache-go-action@v1 + - name: Check out Kubo + uses: actions/checkout@v3 + - name: Restore Go cache + uses: protocol/cache-go-action@v1 with: name: ${{ github.job }} - - run: | + - name: 👉️ If this step failed, go to «Summary» (top left) → inspect the «Failures/Errors» table + run: | make -j 1 test/unit/gotest.junit.xml && [[ ! $(jq -s -c 'map(select(.Action == "fail")) | .[]' test/unit/gotest.json) ]] - - uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # v3.1.0 - if: always() + - name: Upload coverage to Codecov + uses: codecov/codecov-action@81cd2dc8148241f03f5839d295e000b8f761e378 # v3.1.0 + if: failure() || success() with: name: unittests files: coverage/unit_tests.coverprofile - - run: | + - name: Test kubo-as-a-library example + run: | # we want to first test with the kubo version in the go.mod file go test -v ./... @@ -59,8 +65,38 @@ jobs: mv go.mod.bak go.mod mv go.sum.bak go.sum working-directory: docs/examples/kubo-as-a-library - - uses: actions/upload-artifact@v3 + - name: Create a proper JUnit XML report + uses: pl-strflt/gotest-json-to-junit-xml@v1 + with: + input: test/unit/gotest.json + output: test/unit/gotest.junit.xml + if: failure() || success() + - name: Archive the JUnit XML report + uses: actions/upload-artifact@v3 with: name: unit path: test/unit/gotest.junit.xml - if: always() + if: failure() || success() + - name: Create a HTML report + uses: pl-strflt/junit-xml-to-html@v1 + with: + mode: no-frames + input: test/unit/gotest.junit.xml + output: test/unit/gotest.html + if: failure() || success() + - name: Archive the HTML report + uses: actions/upload-artifact@v3 + with: + name: html + path: test/unit/gotest.html + if: failure() || success() + - name: Create a Markdown report + uses: pl-strflt/junit-xml-to-html@v1 + with: + mode: summary + input: test/unit/gotest.junit.xml + output: test/unit/gotest.md + if: failure() || success() + - name: Set the summary + run: cat test/unit/gotest.md >> $GITHUB_STEP_SUMMARY + if: failure() || success() From d23702bbf8513094ca445bea52742d952e80a8dc Mon Sep 17 00:00:00 2001 From: Henrique Dias Date: Tue, 14 Mar 2023 13:51:59 +0100 Subject: [PATCH 53/93] chore: add hamt directory sharding test --- test/sharness/t0115-gateway-dir-listing.sh | 24 ++++++++++++++++-- .../t0115-gateway-dir-listing/README.md | 23 ++++++++++++++++- .../t0115-gateway-dir-listing/hamt-refs.car | Bin 0 -> 782149 bytes 3 files changed, 44 insertions(+), 3 deletions(-) create mode 100644 test/sharness/t0115-gateway-dir-listing/hamt-refs.car diff --git a/test/sharness/t0115-gateway-dir-listing.sh b/test/sharness/t0115-gateway-dir-listing.sh index cf95bf4b05e..4681e63ee62 100755 --- a/test/sharness/t0115-gateway-dir-listing.sh +++ b/test/sharness/t0115-gateway-dir-listing.sh @@ -13,14 +13,34 @@ test_description="Test directory listing (dir-index-html) on the HTTP gateway" test_expect_success "ipfs init" ' export IPFS_PATH="$(pwd)/.ipfs" && - ipfs init --profile=test > /dev/null + ipfs init --empty-repo --profile=test > /dev/null ' test_launch_ipfs_daemon_without_network +# HAMT-sharded directory test. We must execute this test first as we want to +# start from an empty repository and count the exact number of refs we want. +HAMT_CID=bafybeiggvykl7skb2ndlmacg2k5modvudocffxjesexlod2pfvg5yhwrqm +HAMT_REFS_CID=bafybeicv4utmj46mgbpamvw2k6zg4qjs5yvspfnlxz2y6iuey5smjfcn4a +HAMT_REFS_COUNT=963 + +test_expect_success "hamt: import fixture with necessary refs" ' + ipfs dag import ../t0115-gateway-dir-listing/hamt-refs.car && + ipfs refs local | wc -l | tr -d " " > refs_count_actual && + echo $HAMT_REFS_COUNT > refs_count_expected && + test_cmp refs_count_expected refs_count_actual +' + +test_expect_success "hamt: fetch directory from gateway in offline mode" ' + curl --max-time 1 -sD - http://127.0.0.1:$GWAY_PORT/ipfs/$HAMT_CID/ > hamt_list_response && + ipfs refs local | wc -l | tr -d " " > refs_count_actual && + echo $HAMT_REFS_COUNT > refs_count_expected && + test_cmp refs_count_expected refs_count_actual +' + # Import test case # See the static fixtures in ./t0115-gateway-dir-listing/ -test_expect_success "Add the test directory" ' +test_expect_success "add remaining test fixtures" ' ipfs dag import ../t0115-gateway-dir-listing/fixtures.car ' DIR_CID=bafybeig6ka5mlwkl4subqhaiatalkcleo4jgnr3hqwvpmsqfca27cijp3i # ./rootDir/ diff --git a/test/sharness/t0115-gateway-dir-listing/README.md b/test/sharness/t0115-gateway-dir-listing/README.md index 937438bcd65..7da44078ba3 100644 --- a/test/sharness/t0115-gateway-dir-listing/README.md +++ b/test/sharness/t0115-gateway-dir-listing/README.md @@ -2,8 +2,12 @@ - fixtures.car - raw CARv1 +- hamt-refs.car + - raw CARv1 containing all the necessary blocks to present a directory listing + for `bafybeiggvykl7skb2ndlmacg2k5modvudocffxjesexlod2pfvg5yhwrqm`, which is + a directory containing over 10k items. -generated with: +fixutres.car generated with: ```sh # using ipfs version 0.18.1 @@ -30,3 +34,20 @@ ipfs dag export ${DIR_CID} > ./fixtures.car # FILE_CID=bafkreialihlqnf5uwo4byh4n3cmwlntwqzxxs2fg5vanqdi3d7tb2l5xkm # ./rootDir/ą/ę/file-źł.txt # FILE_SIZE=34 ``` + +hamt-refs.car generated with: + +```sh +# using ipfs version 0.18.1 +export IPFS_PATH=$(mktemp -d) +ipfs init --empty-repo +ipfs daemon & +curl http://127.0.0.1:8080/ipfs/bafybeiggvykl7skb2ndlmacg2k5modvudocffxjesexlod2pfvg5yhwrqm/ +killall ipfs +ipfs refs local >> refs +ipfs files mkdir --cid-version 1 /Test +cat refs | xargs -I {} ipfs files cp /ipfs/{} /Test/{} +ipfs files stat /Test +# Grab CID: bafybeicv4utmj46mgbpamvw2k6zg4qjs5yvspfnlxz2y6iuey5smjfcn4a +ipfs dag export bafybeicv4utmj46mgbpamvw2k6zg4qjs5yvspfnlxz2y6iuey5smjfcn4a > ./refs.car +``` diff --git a/test/sharness/t0115-gateway-dir-listing/hamt-refs.car b/test/sharness/t0115-gateway-dir-listing/hamt-refs.car new file mode 100644 index 0000000000000000000000000000000000000000..58069310cc4eccb612a4b272050f4064e2652232 GIT binary patch literal 782149 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

QQ>M{}WU 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

UA01mk_x-eoMFT--vj$_n6ofj$uAlGq>Tjbi($ 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 z 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ν>PP1s0_e2*fv>qoFG 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

QQ>M{}WU z4cNes%{3!pV+T8o2;p3OJ$GVFiupBP(*(EL$KrFMv?s@e;_u;!R}G{ z#~dXpcRZfQiTu9kJ&XsM@wok|8zS|-44K4pgEA4VZAMfzpy zaSCAx-d?FsYJX_PbR*Rm=lAs|c-2u3t=>G;vj9HL`NDbSJKYzS=BCfh`l`Ic*a7zq zx$&azP}V5V6hu+wu#`{kqP zp-PVU+REFqA*UiRy}P{1@1_q-EFCh;?>Eh!H@|%xXYEtARe9dQxu$F|D%fzWvxGoR z{a&0fq(bn?iU}b*k3gpGz|Q5fvv^})l&~^H6|HcF^WHe0)0QZB!VIj>vM`7=6bq4$fdpj9)yz1cK0X5km2@!mwI zP~6hyPK)5EweIZI(+V3}N}-B%zVdyh>NmAmPWI%_lvRi+%R+7<3Ss;{ilOQjU1p~^ zj`RJ;wM0Dvd1bR(pJuvS@cAO8#JRrk@mEU#90f-&A{bvm3MvvlxbyYI^U%gzY_Ews zj-0J+{LhyIZpmjb-*t(wVC-JJp1tqs1uFoBM?3q`5e+AO zR4xI59rk~%!;J0bf|aK8;EO2Yk}M+4H|f>N4^m9axwz^wd?|)93O5vH4Zq$vTn$u^6dk}&d?nriEGBjL5T)nC+)Go(` z^y%Xmo{@ZsYFNpexe-WC`SR0+(M5mScg7vyx>cZ=M>4lB|gtFB$CevvMAXMh0t+e|2NY zm-BuB#iKVS-%GcE4yM#0h-+pFrFh}|Nn50yTFKRNESDXH3FJI%^Ddr^SQSrCo|8@V zN{WuT4u}#I3{uDFa)g*AEvH9Zw2uo|R~y?skdGjF#~X37Tt?k)oI`=m3F8t!AUr;Z z7ojx8&KEQQ!uvGG>dA3$uMc|a1Oz9?F7+P!5ajzXMBO;u!uM<;_+lW@>Ch+i7AA%u zikH#DhCaoCqs^0T{KX&BjJ97#)@FAR}8evqKP&AJXrrM9&`<|WR(fRa*)D^nDQg>XguN_ekbaiD3|V;sZsiR zQBs_;F5|xAuYM9N4(qh~k!(Q53{-x>B!h!%*hHeBuwDsgw9F61k!RESOLK*4&+%H@ zQ+xglrAREC-HR3A!%zh}IY_reJ%ca9==HjT2#PP;^U0reQYrdyo8d*x5|e&{dg&7L zd;Fz)4yzCx7Kf@M#14FgL{EWT`eR2-wtnV?9CtkP#+k3kajzy8mzUH*wnGu``90|j zc;=8{br>9u@

tZQyW{;e4mnl&!%1pMf!EHIuY#cxIZhEB9Y|SlsvoP68R2mw|){ z+abvpxrUJKgbyA6>USU2_TMQL>9Pp*#bA%h{6!k@cCFy;v$+%q4ub<7CFl!|MnlRk zjrv}FvBDkV5ERJnBE0td7^?g_*VHr52VR zQ1wzS^F|mm;<5SXzrii-#SAU3&;&X;Aps=7^7SYaCu8`%(-@I}Led(mpm_9+(9bD+ zLAJ+abC=w`MznH6>wr!{j1Ph5J&*{FNKMi6obr>{A_FD#!efGSqZ`_yYMt{szNOa{ zNuqzM-WLT}Cdx^7#PEi>{&Ax|9=y1TpG-x42ikaTbuw%`xy=MSRB+A~XuJAXQK>%sl}W`2cqI3eJ6*y+#>J6p(@ayq%0$aJ;1BP5hFz zd)Otf8y0ks>!2VHL3Y&n4}LD%BusNHQP zeGYJ|An-E^F1i(?wOymNY6JUao@dUT(l7>F{xSwRKAAEq_Z&5lh?DuB4~J)N z|J=Jow&|Ze#+b%GKSvdo_fw{P6ri-NLHCzbQy{^3pi}mp@`bv)mf0|6+1C(~%oyzT zpchMw7*xd|rvzn1L7*ONqzXw$26>ZQt!z6yPM7pMfhktCNX3Vx%2kH}OEu{|m++rR z$Gc!RDZE$S6c+DJy$4?3FE}$VgEXNg}c-3E5IncJ_+wRrZdo$liO0 zGJc2G)63`cy}sY;=a2W5uJ`G_pZ7TT8 zd#Ibokv!Y_2SxY{<>;iC+A3`=Lc=V$deeq5X-IU9dEHmuRWX!u}kTESm$wR@o z>wQWnQm5y}@P2ba9!UYHxOA|;q0rX|xp=y<%S?WT40$DM|0r({|EVn!p{O@!P@WlE zdGJ2j*nYq7k_>f2BHf_^;&6-qQ`%-J-u~;{p)vF$JQ#1}sGP*T?2S$O zVYSuB`1p@ODz0{y+iu(3uRDJG{GF-9`wQoPf*kOq5vFcFuy>I4c!tLsK&!zuA6rTK zQ8H4>bqv&h2qJDl{?{~i9#9@dsAD?OM0%e)7)s~9s+N4;`F!I}5g(&Oj%?5u zj!s>D(WIs0dzWSawh2LBA=HBv1Ni~SLlDeyUR*w;*4Cu;oWY51iK8@1-GbK~Mh;J^Z>EHsNj zoe!ulyMOKA{xn^G=s`eO$mP$PIvf*;^Y~UwWD@V(c_SUF9>ZWM0~`poK!X{S*xN=l zS`WTZuX9?HmRCbyjQ8SI*Xl9rL|V;f8&Nc>Ww`V*HsDU$FF%J^OCOO&Mlc*n+|1iq zd$I{TgJYVj?{`G}r+iIVo`l$jgl7=UasG1#xWNyFfl$loc2p>!=K}ln*}_Ec5`EI& zpLy) zGK*~_bI)qe9dC4WxBzmJU>~5~gU?8Paac~>CD$4tJ$yeqaO+)Go3pUYrSNSpEVn;C zB{ja-ADiGBKq~zqRk9=GlS(sVJ2H}x9jB<>Q( z0mww)o7+*nF~ex{tm==gLTSyjd|ZU$H)fx{UtWo2G-ac0blav11%Ia$q+K9P*VcaY zK1Bb;SZjK*Quk;~V%YAyimFeYgQbiX&Sv2`ELM?#S{;y+1sV@(U520#0&)!qLYJva zi)uCuliE(>N4b>J+*_X==>F~>R=kj}>bx*@P*1Ua3!PvXB}hLa^W-k`$tlq;+;ANQ zgTjf})zQ(Z^@*iYTI{3(z$Z|s9eG}+z0mI?fxE5@@v2}mFGGZLLazIw^Lx*Pug2O7 z%@`v%JB$M0UXzvuZXU`XuvCkFk7EhHgbT-J-1(A7NZ!etd*uFW%znzVjjuF+^>ja>|hlz$P?5>>ygKWsp&=9WxOAS1|o zSRd;pTD!_bdHi90v0TtF|IX0C5v%ReqZ(h+o1}lbs0X2u?WzU92B?mOXrT^RM&y<^ z&n#lEmz%sw3464BF`zfiUSvZtmBqU{!}|Ce<$!dcQ9%wWbo4ry=EfiNv2<=_Vrg%? zpevHAbSE;acesc;jC=j+r_54DpBE!MbqXLS0?Egy*RE>?EoXVX-reki@OW9H7XRyC zzr_*^xzB0ET(_Ll$Uo_E-Lw$optdujRr-;7TyX7fhR^aW-d6weS7bp*%(g}0>VhYq zoQ()^#%`Ev)poNg$Vq~e6SWQgNGcXwgWKX;cv-$Lj^W#^jpk4Gw{08N+*m7kAy79? z(e0e~CI;l7t0uCZe-qHx;Gx-&$&IKBJ1V}?Zr#Tn+2|;^^eAj`#dz#PF6n$OgzE#l zCn|y(&kx~N!g#+rF65m(D<#;5CC@|s{jXZ3@a(zpyWtu^GuJEj*yb#6|y^ zOQQ5K-sSImWgawtx$&X@U}Isy43^dCna+v@Z57e|aJetPm@3&De_JnzarnuD5I-^Y z{pU=I?~wbtd8FUCD@Fe(i83+#Nw|7mMEJfG^RPan`Ydft4x@L#D+dNzPSMFe&=l#J=%;sC94twnp<(D+P@z5BUfRG1?La+_p=p!X|wwUzh zSWlD%w%UDlA9snqyl+8jO}5rHCyytVx*OB(Z!zzo>n$7V(6hme&j4EeKYrZc?+<2Q zh+6Q^y;DugD-~sr?j{vIJSIo41J3=KTB64LCp=EQ*F}}lhXv5 z!uA^5=#7%Fu#Bd%JU(W;xrWHT8wc7~qaKEiMRfL_a;%NmY?kF|UAw8%gL`H{b*?yi z;cQhy`Rgy8qOQG+A;*^is{g_L^G_!xJPVVjllb4Jj{N1p)c+lncISvqipEv$yV8Gc zev5>)UQ+Cp(~0wC$;1@mzb~suJ$iF^Rz5{<#TPJ~B6qc(leC*N*>e_+fMThDD204Ovcq@Uq2K7lj95PuOqDkiXl9 zbfSm#McyOCWmu{>Ew`o{ZP)#|0=Tn7i7f29zA0}TiahIYiTFX(5&AF*5u_Mfq_GICBX-0YnSIfcs=1kg@WkO#4i{v9Qw`&7s& zrlveUV<$hD`Wx3h6zabqvWa=&;QD zoKM?fyJ&0uQ)69r$NK4`J!44v;RpH@5_|0)L__(1L+|d{+l;Z{h4L|)Nj)Z&(@6Hw zeBc;+_ZUSOPufH9V1py+Fn_iJahbq+d~A7Wn96;zCu+c}6w5C*u;08uO17?7{$l=KWc%yI8;|o%&fi=E z&zd0h)+h=Z!#KxTr|9gk1iNYzZu*Cd9(!>^ymg{M_D`GX4YuCqm1$sw0m&15sRxJc z4>b7Me3hVUBOZk@*6JEm1ZXxfR*nHN)_aU9&p=Ull6186- zm&CGrBU-Z=E1M{6CcMIE>d}@T+jtqSjX-Njx(fL^*uX;jE+iCo$vW!1Y(Qzz85&9S z*xcIm&+j6y#NDmYj5l|!F)(vul4M?!JOjD?q)HTo%+4e|Y;2P?Ir4Eshcm?6wmRwq zL!L+zmD)JFF-1`P8p-6I2`RLV5`tbc2Va+PRMo}qr98%2`jcX~G4w>7$$4gY%xpPH z@55EpTQ62=JDOdD(V(svLb?fTL_ZO2KUn-Yd~Lor#84+U=n<>RpYBV~pt9h5cK=y1 zR;WG9QW)Y{2$%8=WKSS~^|Z9__NMV`;X$U7;_8P#HEj82FjRa3oFdo;URsbVpV_B; zLi4|aY371~k8CzI^`LuNp2csECxTM!EtZvpk4XxNwOpHRbDb~tEQL-S)J>0WKm#7j zO#*q{G;aMVv#}k`QQ|KpbpNCm)VXeIoZR_**}mTz6gdw>yiqUv?;f-|-QC+dLA2nq z!-W6xDOvFQ??FEttTj*Wk&-DrHqV@pUIsbvKOhyBe?qT7WPXvKb{}7S`c9cL{#MC) zOnrcD(k1B|RQOwRP3P{rEan0r6A__KTtPcXGVivTGuqu|R3{SX`@KSBozHKvbf#uB z_+4E5z4jCH1N%T4!oaBceTySGd?g;LeEx0yxXrFx_M3{UiltTJN51ain+9Jg8C5c| z=R@eg%m%kU%1!X10F?^@XE71?`s*OlciI;|noPW<_q+QEPyaU2gDrmu$FI@R#kj>p}V+p;BsIX$(}JfZL(O5Ms^@A2BeO^+y;U zUdGu-22tqdv+_zahxs`VD;0gi@_ct|4Vj|kLu!@Bg(8b#4QxJQl^Dt6;o_}jk8 zkst4p<&TZH+zkq3y=9dHa{Q12ggTC~BWT_K*s+zAkzXhGd{p~tV)rLOX^nHYqb~V- z3%|j7m&`#9^MwA<(2eWh7zZHCR2c8r%Sy7hsmJGP)8F@Jm=NF7`d4|+Vl4fmf=jOD zw`cu|`*RT1%GYNFDvNmoJd|{=o0N;_9|L;at(Ow9j;Ie*{0_ ze&1%4+#*5~f_*rH8{c-}=@T!(e+}<)De5y`Jx^2Up4+(dd_5?{t}zRAkc^PeB03#<)uLO~2^>d|R*UEA}i1~j;2 zoLPj*QwsTNo-G*6tZ9W0S4J`>=Vzvvob3U(%Ry%R!E&rX8aSd_m956tA}x*OR`t&m zIZ(OIZS!Acn8Po#s3FNV!@PY0@_d0X$A=J02TD#H&^BNh<$DB^ZUlP`^SQ7S`_hQF z>DRMhIp(f6V*5{zUklMDBqx#uqZgX;9Sk`C4n1J(<;?zPMgINKe+aOaQKo5kbW z>V10~{GXE4;k9Unw8GmT8xoB5x;M`XG&fdIam;i3d1Kt8NpKob75Yp?6bv=5c&Sr= zqe*ciw`oTWs*jDl)})vAxU&^mr>#Yq!*C-1ij!fV*QPEO0B7){An5PQQN3es0!$rt zI%><4T>QdgZ+quQ^@yv^J+`K#+32FWY{)7Maz^k{ZfxouR}9jp{57{PCk;e#)ID>5aR}7qa4G^Np=J~f2D3Xg<_QlhR!MMu zvXTK~6dU6Osy5fg0dC~%{)f?L^mjNgll_KU!`0*;JL=3y&GIVQ4y!99@!~rNCjbtp zlkvx5Hk$JhxpOqQ_u`kMPlcp-rJp70xvYEFxhb+aZtgsvBBQi+G>X7JVO> zqED$9Bx;o@zf!t=)wvP(qco9&P0%X4Bq$~@!H}?M*E~ARzBcFO7id5o!f?8d90O1H zMQ-N_uMUk4y6D?R_@ABXuzJs$89j7+_oWds_XE%L)Q*k>a6N~U8b#2t` zW3D>vJ(g5Z?E<>QqMqxe*Ju#P!uEmvbarr}G|TfT)RJv z0vM6w1%}(f!Ox#OPDllanb-|u|K~qU6O=W@Nt-cQ%n;E!z(x8&T>F(~07)+$#hPE` zmeeEbDpQ<@!)w}0n5RAEHqmiGm^R0nOU&kU7|8KJK;nXovD_%jl&-~=-;A+*^DPiOIMoebhz+HuZ&o5qX-0PCD z{Pj-aO`^cVoBVJctIbLwIQUk+Urd7ut3`f~OVuhn8Qq+|_NU+9+<|fgb;k|~7@pB6 zRRp@cfvr`jkk(Z&QmQM?v@F}TpE+Ax@Ba5_YvIo)K@MmN2qJ_Cz~OjFQ~@7S zuSAspQg>ypu!_rhN>6tt6+c%}>p7o&&VUaP0HE63Vb|mIZ1i~g*bIr+2w0vqbJ7*< z@mo?8G@AvN>B)_yFtcz*O5O!CfJa6c$XEwADDBmWLxfjBvoLv8=w0ev7pePpGsR0E zu$~(yzR}d}?h%_w|6P*;o_Ja6^(u6-y=SRpXV_#+sYOm$$+KvKn#t#lpFW+}9W$7c zemyLe{1i^0C_o_8INzY~G4dw*(PJ%2eux=DEJC+nsR2LSFn^cdTT*lU%<}Xw zIT6rLd3cb03pz@6;a54^vw5vJT2X`(FHbF(tlP&UmPXNBss7&=k}e!7cv6Aq%#T2e z>^3w6#cBF^d)vN77tcL|)h;xN?)gG}(YL}!@|O6tYV;>e@<9&FQp9z<_yfIf-`&K8 zYEs3*l}&q!JCq)cNnxG(U@XeBHR5SsF~7?MrFWntiy%U{$%sUs|Hs0FQ^!Xay=4li z8?T#2`^WtFl|b^#-jZ0iY2wP@cWRIWh7Xb)6%LW8{S5#;&~yFl5}6vewo0_XwGQ>n zQ;k#v3a2<1gi5|*m#lttJ_Cj#ygSIbEOkS_xJna6(>GsGGvtz=-1PHyV0LG(3H-NQ z$&*92=3dE}3B)Jp^TdN-!>lc|+}f!&i#s874~#A}mYH0$(_gmV{QBFsr@)}rh?OoH zXAtD11fdSu!9D!|HSG7#7tB-YeA@dAZSOG&ItKgqWMmB|a3g;A;IVgo8!Je*l3Q$p z(n8>aL?PwSV6^wbU}~$>A%C}W_7(M6!Pmu8>X@C$SImCZ;spsjUQ^vE2Ot7%%8K{?G$)~%GPlh#2?aS>m=1>OU8z6ijpEuf^*-mcKXnT%l zVxrB-u>2d2#%9}Jj&^41zGu$ogM`6;hBOG&HR$_}+I5(wPzncW@srRFfj?*2$_oE3 z?%kEVT$sTSxL3X$=G9V=08jXS77=PS^AXw;Xy@0%X(4`Zq)$dT*1iySp}ow2@zX-@ zd6zWfcDvpAbG%g`CkYj9P+BY(>F5A*Sl8Cd`Z4Yrsz;bk;0ftua;y)Wf_87K%=EUz zZ+${w*F}H`jA->2`RMCvWN@PI3FFV5PJd1gU-3^aloy0^YkPkya`kcv+;V?k0d}+u zb$k)psgoVQ8=)@#Q%8P+bKK|UD?9b4%BIR#=~cs@`7 z&$W0(f0O7eg=_-dM&z*M?ss?e9l+-q{w^sim!Euvb@2;UcxWfiaZ*-3uJbq^W7xaphyOaAAa^sljpjNHDCFQrR z7G0bh=i{epX7^rW22Ib+7?Nv|C~aT3@+cm*P8xc5APTJ51FgV{*(gYFhr|^&`@1@K%uEfZU}b^3-{^Z{X4sEObJ;_9z$5q zl`uBL=YyNU)`aYE1cJu7qsL?LQaQG`TTshbFNBk#bjo0*-6AL+hj!`0N9`v z$QUuPF_MU&{vw%Mn#2VO8Z6*@OJTT61o>dx<~+dc#Rn!47s2zN^Ln2?5^eiSN2{Kd^VIQCW_m3O;*MrF?q9!k2{_3)rr1?nXIWD)D$8j%P%426-uYE2o>$)6! zvLN~Jc^n&AKfWhoS1+4D^I(=2N3xkE_sq)cxfAmDxSr1JMuLKcwsXQr22m_hnhO+j zbNXI+(rk~^3x+thKQg1`){#+BUD{+lG|d5Y3wdRXASVePJ(MB}A0#C_0R{&?Hd43Z zV4^^pfq#hWwFOm1q?Z|=II-#Jl_Gl@PwQX-+iGX2dXe|ErE6Y?6J_5MQBZbq!Kd+* z(e=jh8e+7iPFd(>$2$23&(bQJ3X+F~fgz7*u;L@8k!*_hRddOg*g-mxxaQwfWrHY1 zyMGghlDDf6C!OIp06Z%S$?Qnj;`i6%g!C{`%KdpVqSqDmhl5EMp(Y)6-7nr$C~sBs zWUbCgi|-3!Kg3&etJE%tK6yO%ihJ{L($;~(LEcw>#lE#_z{Qe{bW*8*${?S3u8RB^ zF>y=Ejeh_Jq#-bmdcK-_(9a&%D-07tsUit_N%r?vhEp0gc~~~KGOv~Xh_Om9ot6f+ zuM9uXBT;BzEr^tm6()W9zbw%It`KrC_lSdzFkFobe{3GBd~nlNxWhH=zft`y)9YoZ z9pQL+i)x;`-@u{jZ<7#H`zl@(_w1r+R=NLOkU_ z&CQIV)qu&{^DPD`|E!O_mA8s1aDL`;aZv0oT@n9unwME*vRwt(DN;fLNGLL@4Xt(z zG~3Kr6|Q&XHsM}MbEG1A`tP9+hwnpO&VLK4cNJemfgBX4MdT9a(Kz&FjKulni~1_3 zXHBr(ck856D*GrdCKk{7PIe{}Cs={S3}GoAgi6v?gI32}Q;#ygZ=cx;EPNDF2CD6Yfm=VJS!uLk@o4AGF%3a{A?p^u|SF-=? z+bhs97xe=Fi$KfK+ROMw*xkfaCXe>XmjOFH2cG*WxZ2E_DEiio(wI58k!L?>-1vwEQnxl^1&lU9dNj=BH z9Uk`cB)zhA_1E>RFL!I*3F$Q~!^7Avo7_vk3a(c^NwDKk`@V$`tKl9ykd0;*;Ino| zb`)1Nm+GH;d+Uy;LkoN2Nc1e9&uI?1;Q*E2U@N0hy|H51{HI&=0+qPGR(v#5Z%vn-D!Kyp2eiUM zi2JigT!sgB#yh7jZ&PB_H0Z`qXjG-;Ep2A6_lFE-gp?R)kb(UnC=L6LazgDwC<2Mh z6#l53ZJX)Lpu72a{*D(1$t~VGT<6pHOt1Bm6bXA{?G9?EOjn~LN4u9aLe^-;iz24K zd(Nw?b?dm*m!wAN zl1;aR5oGV>%IVO$kGyF%!Nk*Q}Jr&w7 zKZbfRJ_n&arsfvsk8f^sah6>kA;i(vqS$hv-^e#R5q6;lvu-7>8a$s+z!Opr5A=}l zkp)o2Anwg%m-sfSgSFY+#Omg5pu(uFdg|BgO7$K$(Puzy5*CD7oCvHaKXF)>_htC8 zjZi60XWhfF?T^E9%q&t!bp%0Z3~6>L$bKNc$EAg5z3)M7xHUGqY_ z!%LPF0j!9B{&yR$mEG`F8u->~$KzQ5qe+V%mT_u1B5t@U&3G|&+3gV752|yd^U>G{ z#LUJMS5oj(XL(>-+%o|?0BV6D#I5zCM7a`TqOGSzXIEw~x%tZ2O^@409W!XrA^jF8 z8_rv7ybAtjAfH0w;lZl-A+`VD)-;trB}yyI6w$@5UkiMvb>I4C(RuH_Ef%>Qmsw3p z+Xo;Ad}9O@7D1p&7zKHi3O>yqXIW676TYWNc}dr(=tNK<39=zE#yxXmYkd=%eDF>_E>c~>=!vcGv!lOK6 zfk(cIE{}zo|JX%%^4uZku~7>#e0M3Ex2i8_f*vabc;b@KdjL^hBS+aTY5Hg6+J3%S zY7}?UWYn$y`#0@XjO0ZNOlcL8z4eMZfMSx8;JZR8lYk+#1;OkhID7Sx|74H-gMzce zZa?=zJdO!jDb&CIGSPLHYUl617ZRLMsCoJv@$TO`@jk!mhGl;`>+bZ6JT3059-#`- zDlEKQOSQc7(VswBN=ZRd4ie9qMTbLMBahXWSTy0zH!AuSueVV-)6EIgHGEb0b6kG- zf>ZX$emdr1#fS_fcn!PvZMnTnjGC@OBqEno=hslnPMB{(ynRc*&V+5F9Yb{_zyjb} zBi8WG3{>0+bn|(~&SOo&#?Rl%&2`S3tZ%;|7xJ?c&hPsZnA*p|6o&ex-z*Dga%@QJj;s#1&kwqBdRinIYyeRqC~7Zj^m91aBlV?D!MuNL6Ri z(aX zcKIR0r@dZ&;Kh&=6olR?2lLz;LtBjggIC4ppG!WIa$T&SS7dptvC&d((kJY4G5ymP zx24i1$nD!yD5bKth=gGsthIO^muG^tHFT-M%kg0y~7RN&j zmrf0%u0)fyf7Eb6ph(1F0JyRnt?iwpF0b&GJe8;xywDS0GD=eQRC0Dt@#SFLyPT{o z86~0vK6h{@THAA7=1WsovPwA?(D`JEB+W?X+meKF2*PbZ5#Xpm=o$XV zhQj>hUf(iUjnwstSL67c;O)}!K1w;MbZpWll)&%3cyWU5zB$6jk9ZZEp<**~P%rnq zebRl!M#af|kdjx$DZOd9P`V@Cvi_%y(-WqE^8?^66{60KLz9I{HonVamKTGQUpm`aEF!#$oc;0Tj@D=Yha+rqv?YLm#%x`*e~sc6MbX0 zcVdVHYmILL=m0_^@>!AaI3u4mQ~I#hj^u|aN38m7$FG5`F;pvthWGNk6SKc?&8pD? z2oR8?j?dyfJQg^QdGizFOE!`w-zO^h#=a+ujVIBw#Yr$fwHivq7Y0u8{f|O;$A6A0 zlZlW0_2mdAbWCjNNHxveYxQy#OYL{mT#s}-S$QchTyP(xz_mp^C!djYGf*r(X9%aK zdFNhEFUBMf#GUD0=2fJ3lepnqbt_+OcF*MQKInkcgnFD?k&>{m&0<`nMZc zPfu-l9dth*Pf=>HIMDF#VPaA@Wxen*FTT*t-EL7F~|W?9pPC-BS9?Kznm$BV*?JMX6t4- z*IBbQt;2d;R%zL}e!W$GUpbh42N&ev{X)FJF-XH)kZY>eea+K2^t>{5qAdH|iyIPZkHO+M8_!h6!#EqU#^OT)L56bl&O6-9T zFILU zNzh{f_0HxW>Fd^a1~(sWxaZhOg*QF8vXFS^`kaLJr6MNIj=nl)!~4L|6Xg{KMR~BE z8!_m2MfZ=tN&m{5JXPV$;}Yr)Ttpk0B&WB#zgwnyOnAHNKs^@dVtCktq#ZHx;9S!W z)9|y8TKpU8UM_ZfrY7wYHtY4&JH7J9$s(P-G&|rR0)ObR{>xYa`uj$uJvOTGKEJ$y zo9NEsx+(ohQq25i5woS(tJ5JvrQoC|l!Wj;a<2b|qhaS5)sx}8_8ZuK=Xe9!O~ok; z-x_iMETWi`tGhOICbV=H@CQJ51Q5g_75-qJw)a{|)%WD^9^j7|;Z1rbj0Y^7%Xr_# z6lwZtDfS}|1aH760)_pGd5?07@1&3(%A6u^FDe5+Nb$P|`i{(u7gf6(cq@h}< z5bFNrAEk*B+%#+I(s*fHrs&oSBmSNc0J5N454Z-38IXNh5go5!)S*ZI5>%y-+f46kq zH~&ITnz;$zj%1=VKOLJrq##v&jJESb6PZG+zB#N?4+8%~k*<}@*j=PVA5uG4^=mx<) zSt-H8iiTk$XlH_l@$-BpOWRQ2hI=Q@tD7tCh!OIHjPCAmyV#|>)RgJ~?t!kxNTR~a zx9H%r;&x{UU$uN=TSL&JOiP<>%qK*F0EHe49I}+0XR*kBU{_&a{MhFyFrxVM69;K>+~qTkAMUEA_j%OXP>?95-u$ZI zf2&36Z&;!%cL?R+v%~jr$tvp&CI_<+`*xUx&*|m$6w4Z#EDYOmOO@vrl`q@^7y|9( zL=mgSyAQoi$=qx&9+a}%I+7F5==cjy@390#D$!i~;Q2M7XvWPO^ad}a_aPLJrW&-~ zxF$hsp2$}s(iI}!BCgZlCLs0GIo2oWg=aBKPw)gKtP{`&p=H6r`58i-Jg}b+@Zy{( zpJDOTdKwKn*H=A{lQM0HAF{-=Pqqpg%yRkxa?m&ed7sKt(C3Gw2=}AD729Si->d3D zGnPj!lpd$DvF%$)^m>*!KkPzGfe-WzV&paeDFD%@JHtB>CcB@l%KX$ATF%Np8!{Ik zY%vMSyXvWZhKjfxoG$Qr5C=b)XD^b63wpo*dZk#*&p=&4pKF}YyaX^B%e-w2(g*tY zcmpnecbS0igLVdd2%{zpsqhKkXLsr{fB%ydDUujAQ{$vCpId@E*X&bVF1<*(KXvn2 zA#lebDUBDAD>^cB$F#nad9}|r>njjv?>&0dqBp%_!%j-sDE9JaVq~l0SCE5_tB8Ip zuSM^}V4-h>NfI}~-;2%pzcD9dCjOoE+;O~LGvY?7>Lv@7CHI{*0*G_(#RMAP>jkG4 z2&4*Z`4{p{+7)VFWct#>p2JLg_j2{3Z23+d@IS#U;79DhG^BwFtjkAXQ#|)}!9;!L z79*0_V+kL&Xiucn1o<0hw|(w(?j{0!v0rEv^*+Tkq2K#5gWZL-fv*KTDXsNs^YV z(o}!wF@yIP8Y3O1-FiWQ4cYfA0?%x^8RNR*u?np@@0+E(4i&K0icQZa{Mf#3kTa_W za)8$m`)m^8d5GML>m`;s6i!6))z+pyckYBm`zb=v&&uq~q->r4ba6;-Uy8a!5AQ9a6uqZ)r7DbK~ z&cf-RH*qeGVT;~-tZ_;hr+ebz-|mn%VsU`egy8{2NDQG}==XEn#n4W&?74Q47Q^F4 zBDnl}`482R#+%t&#=L*tRM6K7{K?e6>Wp_% zRyBu>_Nm1`trKA&T)L-7CJdXPc@UAFS z;zjVTes-Jwfzvp6eXpK!C8*zSsz>FSQ_xqnOTAvX6YAU)D zsz)tmSu%Cpzp(m*j+c3CKKa+w4F_hn>{-{@j?61X3QAo(ToG%?}xZ znQqZ6U9oK14so-E^9W^+M3LCvPb9w*_RXQuKJ%@^l;p=rtj?b)`GqWj(o?TF=TlbK zt$39<=nOy(9$dtHt3VRxK#q9y3$B!(nfryJ(kw*}r=RNl|Jui0RNG6;eEWXg;hFLBXCGQ?z-juv+Z%xsQp-qFQixUQNke!U!IfF%L zxu%QO;+QWX zo?MWZkiEtNb-ewFeLS)6a633Je+SU#(`s&Um_(5m+kPrPPG0rPKNdmPRKJl&Y$HFj ze_HQ7*4W1d``IZ6a!X4{rCcmb=&FN_YbL>n?ahcGf$c7J8-wQoZwXa(aBD(^Y)EZ9m`6b%THohH4KKO|W2ek2w-2=!$ykQG7j-#j zq?hx&w^R0&O5+tcN8ryv+!SAqoXb;FpDJ`7tgu{`yJf!oK(Nm19SwG|rCbUA!u=C7 zt{pGny9Gewpzc@iA2JlaK|*qe$LiBW-EaUjj* zc^Bnp{Hh+cr4ntgO0PAutlacVtq-<-n5ek`$DCIZ%n;Q4LsHRds`#VV?wDl!1AE={ zTuQ79ZT?>G^)I}Z`bG4&Axx6k7{=p;<{L;_aC-{c%&Hn*kficK9g#X>fD!K|>jYvz7$z3dCE46ERK7^Y2`AYs>RFYrJRWe>vRxG$`tG z4eXLC&$qo61kNC^)lt^cBr;9-yqK^u)+_G5bUo+C;=OOTRk%-U<^QO?xxU=;>&G~z zId}p1Ae{tZ)$bkMV&xQqpl=>im@Z>Pxic;sUv2MJa|sGty?tRI6!%2oHd_6eL97YknsEr|Nh zJT}8@oIP!?kKHtS?Y%}ZfO)|35b8ZpwrNmI2?0&m84`|lCrjF?HD8%eO}ln4oVg!s zST~(zIIk#I^ZV6H;K)JuzAUE0|Nl7&9{*Cl5mv&exM$n78Xh)FhCVX~#?oO+KK(TZ zHfR_sB1%0_j>=7g^;5tlZg@Io{53=4vXNgXue0t&M;--9cY_nm&BZ$GsSw$PZhr#E z`h7zPPaxOjbc~?uN3@VgT@Wu$)Jr_R(`2s$PI5;6>rE)@yws8la?-$nK|NwcYiMo4 ztS3s#ehV|)ka|lY6<1m5-A#(&*{~7J7u>NOM*PG;%!1li{D_g!3Q-(n9SANvxb@Cm zRp}44Xd3FpvKja68?mo!(PNwvS{&(>Pk=TAg49X5Xh!y*KHOOMJbZnxrOG%H{A2Q` z&&J1@_iQ-&v;=&4prWG-U``acnyB;S4<+M}ai()3nw*rf?Gh{78YSfWJ}GfKoqJ;I zo1OlPkZfc99OQpX^HYa>Lyz+wOHO5=<09vY&j$Lz%EstA$Io+PzU-?x!tz5)2F1_%{w+JiTXPa;yU>QV_?D^8q zXt}+4?8}#wbG&rouM3cn`iVK^_?_#s=gd)eb3UT7lGj0d>XxsW4%;v2<{P$<~&n z<}-ujs*}R)fc1|8h2y^U%z-l?2eoLC24928Xy-@rLZq40`yiedvI)!78RJ)Z?uO`N zFnYYRC|78B?ot5iSVmG9DDem9Jq&T~z<3N2Q6ejB_w}>>o|eVo7@w?b_O>*SGj+i| zGvb);CIf0!28wwhdMEU#n1|bTQpZyH;NO)`7z~~kgFloXEOL)M*ur^*K4w2*}aZ3N6T zBCXKj{Oc<^CG1)^dL-!j5cNN-6X{II6y>Bg`{!qmGgJSCwrU^5iSi&u_F)5L7%w(l z`ZKGM?=ie_f%Rf%@3R>^jd_nOhgCezy}c392Dn3?#;{w+BjL=3}Dxx&m+v> zDR!-RbdQIeQ(K_B#hLK3!r}(GoSHSr$w6^6)Op@ZJwbQ@oI{L(Sne3IRT$@?l>#FV zBNjDOSzwgJU~`uj&RN|c z1C}3$=!q=OUtdBt+DSCJn9z0bL!RgLx@nrKhXbeHmPf0&=vu;ohc=jq_3if^eE>x} ziS7z1Zf*Hm8htz!jw!365grlS)A*F_c;31=ULQmSWTb#Hk5Yg$$;VN|J$%SE`@en; zu+tpT0d~qwU>44Iz{gSz8fAx&ceioL{Nn**VbZ5!lkEI zwvY4OdLYVn{M8D$njud{7zs_(AEmfbDc`QqCgf%nu@QXpl%bM-N$sA& zrotYCCU_tX9dR{p&7of>#jr~kuX65Dv(bL<+L0!=}a&8Ftxf*ixM~pA9whnsnx<~)(CQP@CcwlP*4_{ z>FmjPiRRKn6UHwe#x9&O&YrRAWm(qsvhgj=tLqk@7#)H-7W}~cIJo5LvFPEhmuB;K z`t)zsH&n2m$kQ6EN8nJC8t>{{s$_X=G@wj2igYphRvD6~aY`U~|Vx{n!r z4pg6Fv*ZV8Cm?i)wK5R0GMo|>M==kn@&xt8Pmf|=3|JWq7kqwW!12@M;$4DCgYwly zfOc@e5eQnofL;!pSjmv6JKW5oKjkC*r=!@vzVd3gT|0J}LNu2{wnyhOU@d?Y2qauT zDpt_Ea8|mg|1r<%+?jN}x$~NVv-%qEe#zY(4|ruxMg zKWangx0%aClQ#4yV=nAWjmO=VExne%W^rQIQvhr6f&qkbxc>Z!HvFny*n4*|*JtMA zKA*-{CCxN{^F@g_jJAc;iDaEaF6<#-CVuezpl;7Qq~0a0%aB+w@wwjCuf>IUYvtxI z-K8U);|$O3xk@y=>hZnylnvwnGaW+ZdGu+ZoEn-G_?}) zi>9h*^8E_vSZEA-=;$9tTG+sNk*beKEdPe>7&NRYh)K#__Q~0x;FEM1ns_}KU}u5> zmX44du+>oC*M#Jm!oF)3F{YgR&JY*pc%LS;%I7kZ9u+aE` z3x;m&$O8&l3G!1UH(kGCmeRpf<_qjHe>;T`r+rZKih4yzy$LjA1C{+q_A-tFH z`{(YJsZd}(t!1#5SR#!c#XiAYFrYMj-TUgXdtiV={20N?egS9)9Hn%wDTYDjFcdRv zzE9cXqIBuu?p(f{W*MWF8Ku~#$3RTsq23xm^AY5kUFkoR1SZGY4S$YXnBSliSY_s| zj^+@z8@t+N`wtw+;NSp@{os6M9N7TF7?>6&H}zsRv855hEiRAPAtsAH{OI1gR?dP z=l^CsAAZKcf^VW0ymscSnAu&f7A55<-OuC7?w*-!n3V}%I?G1rC^zrFI-I(ezJ?9sGv;a`5G;s4uT${CsPe zPJnmbdfM>;Uk0st7Iw$YNA;4QZ`Oyh%_tlmwM+4W%u10A)utwVIHjb$zxTee&%b|s zJ~iMe$ydf^YVdXPLlHVe^(TKrqatM%hqF1Mx&k;&+)f;R>QCGKv+;4v*Lsp8zu5a) z=9ul9%Y26wu{V2>6z~0c9y*o|CX1@y#5?=<0d?1p{^B7yui&-i4avusIF#xNHg*!j zSx#!vksof;ta`Sx>__6JoDVOXM27`5D5#UDKYvOQv1Tl@XB7%a-G6=s00$kMvCr?( z?-U;6`LGM8MzdnAEX~i9JZ$0{r(}-p=MW>LePVpacpiu{((v3MdF-DDkjn4>TfQ{R zpAoqpeh2(|UW#ARr%Ss2xw!}85?|I3yFfx@U8cX-#&db+(X{#F-otfvnQPk8mJr9! zX?k>>**7z-jz*APdODA`WApRXP0eNCuE8mR9K(aD&y1qiIdqO!qTeiRO&lZ(xo||E%%WZ0p!v(=yOt-| zP;=$FluU>4NAPv>iU{%}Pf3jzTGeU`BwJLsr#aC3=w{;WpJ{sN2LVOC6Vu zj*T$WJm)I8OmzF#Sn_Sd0RnydK8I3IHsM8_1(uk2hOyf)FL0(JoTVgR^br?Y+Zf!km4rDarL)E672DCc@zxMiK_#X8&^gK3n(ZJDW?Fl?6%MAG##h zKG_6Cu0pSIDq*6b9chr05drqY!G3umUNRW(MzXxt#C577l@mO7=7b#PlTO4%reEtF zmLXxCUlB4_hWo@T3bh*!UN<1J01*Yg;WW*>=ds&JDYwT8wmoB#&ZwYGS^DnXweoYLGzDh{~6K$$?U#1zzA zLFO4}&VIw+Z)QWSC~W6*7O&7J>!&sBNuROT&YK*k`nd#8IB>^!kbMXoCOL$%|KE}b zSVFwiUy;&7u#P?DT|V0}Ee<=QRsji_7aAV^BC$0Iv9Nz|BL-t;Y7_JlO< z!idao}Osdd`Bi4}cK0qPJ+(D3iY#G|EL3P3Wbjz(r<;o$0 z)K%q`x3wBC=_g!T%D7>_=RU9N1osmdV^AypV8838QS*fFBM*EvBS_sXkn;(iuQ_+j2!}M8+)y$1OGPRM*N^^w z9AalO^VN@^!w#N!V7jATs^x6-JbUD-S`tYY2lUvO^>!4uW*^PReIS3aa!2VC{S{Z% z)06-WV46s*ZzKdI2lrrnEB41GO?5%a_Sn>@?dbby9plQd!RSv3YfbmsqOsv+6b0@w z5^E`%MY~~tH+1L|Y18iv4r)!yXwcmmeR5y=T%~eAdg$6Mr~NEWZw6>**Ha_~M%1JwZW^2EiX>m}$7_??_6 zbn{gCs@sbxuBpB(!sQ8$#3SXit}&_lxn5I5A2XJ9N`&aeGR5>x zd4j~vK=%T`n!;e`qK13rj=rqf-fR)y#Xj#jtYx(+Y?}z54As3DT0y{AXsmfkj#C~k zj|}v9MU+Y}knXp#qBLtCcsOOBFO22b- z?~)7;f!4~pfH=#pctgSj=`6@W`UGOXht8noDiv=ec*hoH%$i=ichAILs%Mn@?n4v9 z_5Aa{^c8Fj8$oWr{S68PMf@Q_`2z7@V_-aXQ>`E)Q^049mcYOu$M{Z$?E$XA3mEl` z7-R=Pvg3eI&l}b=lvYL5%67c(Y+u>`BkaB7v3}dQab%MfB4n?M?9sH9QY2)HB!!TK z3R&5dy+^XQh-|X=rig4s+1Z|h>*I3Y_wRXLzyA34?T_>IIj{3P&f|C=>wVCaR9yLR zdon_JLp@3QuD=Rt{oxNF)YG7=ebb)v+Nbs`Nt5I~VxGS8uSIFE%C#>t-{vBPiUK|; zfJQ1)=L*qQ(`mD2T(T!+u;0CifvUmtAq_78mp8fQE=&wZ!oG zyx=~;kHa^%NjzV3m#7g1mYa#x6N4wq4|oZY^f~CiLUNd5+LKlFac4pTn@%q_J#NB2 zr$az`y<3@9D(Y0WUuJvPeq8J@pp*O+troL*cN%{>@T>&XrVP5BzDZSReJnx#mvz(e zM!^lu%lH`kXcGwIP(SZmC;B|885ahK*E)k~?^J(CoVF&r^PM8!;`Uw>OIm>YhZXyM zlnNCS$g$M5qYLu`Y1%pGwnLRrG zXyvNnI45}fqihRj#Ce-gkvr^^e|zgGKCDu2U1%=bcMk!Bqv8p}u4px-I{RSariT)H zCq~m1nrBNl>+(Yk^|L1fS4uAA44F_-!`Mu))hKcA&O$#ECz|ZOQ~~Oz^U2nMdD63= z#H1TbCx%FkYsY*huHF3w?!TZY)YqWa`9psaqHccC`~LA;TtD$}FfLE0;CURE=kVGS z+@0X41W|#j9SgG1KOjgG;Erx0)NuJ6FtTG-Kf%k!_>Nn7N9Ou{rb_=sHJMw~1*>*vH!*^MR3NP#ME$TZ@d?;nkNcJciOM|+B&@eRrA3Op#f7Cj- zHi;O2>r8VV`DquYp^F1H9JB64%A0t+zue3G&7?0?+=X@fbeE{}7+6DJHy3MLc(o)2 zk-OGOG1;8(Zgs^!xBuo^1^x10%S%q{WrKBK;}Oi$4r&`wZ{2nCw_J9WG|Du;(~a5s zEXGtDxCPMV(@<<7 zzWS={B9Os|9!BBjKcSD)>(BJdN}bF%qpvXs-V%3gnK&p(G`?88f#uw217(!&;d3&; zmV&qp?PzS!DQVL>n*37zxZ1!;-JIg6nIhfo)i*M$Lze@Jck~n|_MtBSA+>KsCK^IY zOslc8Mq)cq$(5Jf_(5}?@BVWFiLREW?Ff8#E2|#>1tI?WUSwqKfmPP_*WdTl^Dc65wR*d>S1QNBENZA_Ji0XoOIo2 z%Pai2mt155OuIkU=*1QWCrqjXLhS+(Un>I*IwfNIU}lTCorCKV!w%{mJdD&1Syg* z+56zR#MYwaqDu1blPd#>HQzNKM`?e09=I}(6Zl=3!7#mm-5hIRd_S`bn?ri}w~#S2 zfKf@KZ6+BwI6eP;ne>}c`~D~_k|kttyeG_0{YUsRzd`e?8V-JV{K-qd?Hl&u!x9 z4?Xk;s0xV&_aKxb@SJU?Ei?G*96bC_Mb{frkB%@r?;jD|vP->)s~uv&k?sajWJzcU zLa8h7qtFD4jUDLic-8heO4>`0}M=zm+~*zD|=2Z6R{|)Y+)-Wv!!sUwfx}?jvT$ z?$cNk+QX+R%C1!L7n^x>B*$#B3eUI`Xu&#Zu%W2)|GkWi2cpEn#*o0e_6Gio!6bpv zfx*I*BSE8&j}ebS#!if(d4Q@=>>~W}-=D7+wK;XgCd|-LcGY|_efIHr;lxAZ&em<* z>l|obF-~=D`$5MUiF-`lFJ5StHpPE%4ExU8$b8@6uUD=9!%47PKxBawPQ7VI3+y|F z*)(6Bwjjrr`7px8z9Ar`m)=U}5L z2SHB(Q^`+cqGFW`zeidgw>vD_@Se(yXBUtYk{-|b%9(<~*&yixRj+dk_;cOs$%xf< zgGR{|{;^?u6v;T}xOseD^MjxT1U(@?fMgqY(HnJoTWqwvUR2I*ym@BtdV`!*>rL^Q zikbeWpXa9NLvi)M@WGf51Xa22kq}ZqE}KB&zapL}zI}o41a1l`>VUvC&vdm-JC=4` z4DGt7&K?`gdK><|O8*W`5zYOZHCu9-N;j`@#FDdS*c%V2CJS-m__&_NtuMHx?FBjt z!ZgU;?rfm(A0>CO;8_-@#LCi_*c9nKiP(ZOq?jxO7aSURABAi5^?~fdU@IhS_`ww! z)ai6^p!@&XPh|YhpM!I5IldqE7HD6d&&+Fcqx4?hBdMuf+EJJBI&mFu&^E^0H+{78 z;-O}cU7ig3{i*9~_V!1!2ZhY{sGm}N$*3Icv%_&J$@wP}z8~}yJEV;nj7LlKwrk<^ z*w6b`my|I6zBX@s7KOo(n~BFx6g*$euX_hF21ssJqxC!MtX_4o?(Tj>Zdi7d_u2TS#7aVsul_3l-@ ze42MB9o9(#OCU;&8h20+9gc5&)bG_S-O|*3r-jccb~V~lwDfg#hcER1_NA=TE!4!2fp5AJ^}qMko`+sDyxy4e1|BMw0n(E?U10T_X(k)J5pTxwUo3 z4YbLw6nwIn>cH+J?Qv6FnB)W=<{Un>l*AS`9&meJ}QRK;~_U{zs#r~ zNgXkoOTfXIW(sLH8?A}^qPkCIkUH`gE#hZ zCFHMBF}U!0^gbV^Gs_M6KG1V4a;qPW9LP7&7b>Gmi|pv_x449#^A_$;LMPN z`b`jAPwLJ}=_D>1v)WC5LsI|wxM;lI!px|#7le|{PMTyuX_u%Rjqg9Sp%e)(_fV%) z;nq98Gh^G>{5h{FtND+};QI5^oI{Pm9hV`7wl5~A{S5`6ai~D?4KFg?Wg{M9cP=;P zw@*7r{R;J`b?y1SY~VhAxYf2F6FY1t_J&{#0+;>1HUF_U3dBF&sYm-)$U^3Z?A ze`B`@Bj~5*kI#a5NrBc!Vrg!B=;!l*w3h_ehONtHk6W&Ru_ow6X+$Hfczejz`ifxI zztew8b9}7%lbRo8f#Fl-Kjmd@%OdQ&+g_7XGi)Sp?jFs;0{Q` zOh_aIx;l)mM0&ETxa7;_^)^!R6(g^xXROv!LOR@;`BRG5J5L{PcL%YQhALtNr-XK( z#W{0~!jO;s-Y0##WJZ@htTT4aCRpk^Q$k4Knq|b19IIL&xL&(iaKi$A|d|X zE6*+^<2CWfFdo5@wtJ948U#wEe9a%03gOD4_`dZ(fCK#cLx76?I3Y^VT0vf6K(>lra2d# z$_g_(tdj)kN2#y$Ni?0sF{#+-`~~v+*COSYntqC|&OD@8!jUbsbdXM;c`_#k77y?Z z;vH2ZMGEk_ERiKLEh6=M=3n$x7M-tDQ?1B8wDNZhPP(Xs-(=4W?t`2-%m75aww_2- zi~zJyOa}|eXWW{!%}6c19qy^l){|5!;~jj;&)QgcBF!La4rJJn4M!EvK;a-NXe5P& z%O!z!_)Eu#u|~4?;Iaq8@tq8R8Vw6xP-D6)H|x)nKE#*VMaZ8Tqqnr zPD)4(sNwj3F-#xq7B#C;(5_Hnz=y^gD_gtty(#hX9dgYiQnQBd;TvrZa~;^2hp!}w z-WoHsHjl$Jwnu|DSzH%WH|f+cJ9gGk0`BL%6VD;9E+`8HW2mqGI%-a|{@@h5NB8w! zH^KI)k?%`*Hdi86&y(JIia}|0*`Uy{ejkNG(-=zHgFYa~{eQs=2k=4S;J*k+D?}al z%bD|6W!Np=KfI8CTKQW&n^mS{wQDHud)xKEhSbW0L-4Tp<0~&mjNZ5lDHztQ zC?8)Go=|{#J)nm?j74wxAj2A&kc}dLVg2X6QAujS7*6k}#_|^Ro{`E8r3TM4ms?ZYGRO2F{J?^VPLx6T*rGYgB zC9lzAXtma2=3xcZ56+n@YS%9@P*k_3WLOJ!>9E~P#>U+d*JuFs1Vj0dgYR%Tjv7z? z|1E(yyov*vLGh6bR%86EXxzD}u@P~;xx`QX$cmMxE1Ot`tGB#)1-v>ogbvReQpi)4ovb}HUNv^kQ$ElVj6zXq3e?OQf{z|R9wqhLH z&_zL$rsDeSIVumZlrlhEg8IQJdE|tQuyblAWV44Sjr!-owoxpHLjO8(>LN?RnZsA| z_v{vph_rlj0$S@WBU86%+fv7G9B%t=5KGE+ssJN`I%=#}77G*p#j92+_GyyXW3yeZ z`p3Xw;uC;|P?VuADMVRZ&_p%lT$w^^qjGOqGuM(?`{Hm%`x8z*Ce?GoX!$%V*uxB7 zf!uye?}0{%A16bx96BM}{*S*anXSVrdMiuSm4bN`8J$r(bD2nY2L8sIQZ->=))lN(^BF@bdT&yWyHdj`H%Pklh}f zF3NWjX7E&{h^{HVHJH~EhP%8iqt(-Ub3Q%#WO?A4;HQd-!;Sv^MDe8K&iS(!a80=8 z&XPyG77tm;QvO+!d2S^p`B(_RAUInwFZYnd$<*p;k} zZiSO}4W+8kL(a3gV-tvoV94iE|kFe?AAKTar-M#+Y-C`-WIGfCubZJ6_q znNAK&5Hg$0L}RWKsBdzA3w}p^uzR@Uz>u@gP6p&X5wjDyqvBBR&FH^wH2gmHeh<&x z2JymY>+lw(g$})XZ-mnr%&dKXbc&KRgWT5`Dx>yqcU>Q_TFl~~J64Vr<}sdQmy-{& zAr2%8sHcz@NQ#n;Lw)z3>g3?aR}XZyu#j%K_rFV#lZCFoV!k$hV$=(B#th6h%%c%0 z*)FTKKRj}Z-#TVrFW=l5))qh0Shyv0x8T`3&n#P6Nt|e!r_s&(kyEI=JM2)KMkDce z3dd(TOE%h{J!sl1^^sY=VK`|0FzRldaE-O}2N5?q*z|t=73v*!A59y}cQoc;Yzvwd zGV1=$-2KpIlc9s|H%H{90dlq5Uh8Z*a8)ue&D2fUe_ zyKD3~hKz|6 z)tls51Um2o38_b5`}>ppQ194h4cY$xThf>gw~s2_6V@Y^YsppWa~sOR=QEFeH@0?4 zwllnErH`(=j^fwIl0R=Pn2BCd%@P3nttj`ybP}*QQVyep(@xQ@F4Do zY;P@P=L93(PNV=aPO5rW=Xlyh4(i%va#suPlU*Mp(i z+fmIb9mmyT+vkljtY7q_+Wynk=g(XqSP$NZAfg=t`;Vh$Xhl>FeXT!8ZlG41zQgy=Lf`^@IPj=T=GWVvn9vbmsj0N+_&hkbO+{8-}J|AA8S@|{2%4O+sv~gOiNTQSl|3O)pb2qwT*Uvuj znTP36I&1sXjhdS4MLY4F66EquKekoX7Ip>lY9N#X^?3+d%|4oxL-!+Hc-g^LSm{@t zW*%YV@oQf!<*g+|q#{;2p1TpN?7{8BJOc!5ee*=`4}Vu-MMiB^@ZkyiTh^VgH}Cwt z(RzZhabW5L=N+*>Wzdx+BtkR4$#*DaWnV3sLlaH1KQ!AdEb3qp((M$!)ma#(AV1Od z;+Kw89%y3$0dd6V^o9%|5*vTouzsD}HgzcU`@9P^QOAQzQMyrP@5=wA`wvptiCIQ~ zLKG4>9A&=(ExX7%;!CjO~aA=j)N z-FRCuenHPH2Ft4UEa#wk7hS3B(2fP~=Vbdc<|mRN1tkl0QwP$~7J}B>_N5BUNv`V0 zg77bR%X?ch4-ScvJka^~Az@C#TGuK9A}^v)9*^j4KcExc{~Q=M%%q-NYnzB4FZ-n; zC+loAstgl#r@8T^Z<0Q|TgIUJaDToY%z-)hTw)OVR0u}CPrhQ{*@{%8<6CI2DU0|{ zAJpJnGwl z^^-6f2&fcMpNk7XBl(R00o~9NAJHztT8`$_HvttmobspNp6f4A%J5`cde3nXe-S`D zm-un?y5bj3kBY3VIap|#IDTi1JN=DaHvcvD#337lR@|`B5m$-y2j2@b+MN9{uHna?+(4q!Cr+EEjxW&5 z!C>QeeV+LBXMaeeOF`Bi38a**qtAtDJ;=z?bgM(Nk7JAN&n=42nb|q zt-shWN&+@ZB(LzU0v$I~RW`J4mERr58ZZ#$P;C;5DfuIH{}MjMm3zV|TBaGnkYEz0 z@yKU7l**G%%;j|Pu8bBtbVRk7_L`>|i(g^B{AB#YwTV7DLnv^+hzWXY52Pe26)jya zBA+`s3f^fhCJD*)qo&CfYu0~BD}CCEK&FQ^f5SEgwkHdk9JOvR9DQw4nDZ^695Ier z-sfBIR)ud6A9q|Vd;9$Cxc%(2wqKF5U_OCF3MsAIjYZ?rt@($FVj9;^Cc9p6D!KEgNQ@M9tUT|H#Bv|33<9@y|=#p(*j-*aAyUD4S%u7rNZl5ZA!tk&tq zWsl>Y{YgFiKv@|mX+`7`;i-dH{^_|u^&elmMvEce{)j}KH?#3sq<3qGSyLF6rz(@5 z0)&;5g>*Q|G$#!sp#(@rkx5|6VKQCEcak8(V8U{GL}%Ng5(lOh)lVVP z^kk(eFO2_7*!onx@YZdMzdG&GJTJ|yT|5Mo2$k#(wJG-!0fnDBeMm$su93gpz?Fg& z`P5g8)ww}jW7?OhC7}2k5{HLGUqMI3kDTWttiG)(ohg{aMFG-w)kK+m=hWtp#Db!!IY>lf@r7Rti=?y36=SQ!)w0!jyR=XXA_rx+x^kXsWTk*E~0jFtv8;OnPm3<+66-| z3WfQIbW8*LD{@)OvNyMgA_70n@Y~7nvJ7xCja3-ma!iZ(`^niSF~%Jqq)`sI&`?S% zES&@uMmXB@f4SxG0}hTG6?zh_vRZs=GG*mw%Y4yTdA9?G&~W-<~v z+`=?-?#ewO98t})3mvkYc0J#xOk-lnCYQ*#=dNW&*eip8%0XNawS|@-v^61qIU42G zekDX>jh_q0FiO(iyMBz|tr5QfW_?o$>E;s1i!{tQMp+@}07PE)5!li8;UE9==imqI z9+ZcPZQp7$#UM0oy>sl1KaCuj=GrT+pf$5T*C(kD72EqW4}U;a=%u?gCwz6;oW89~ zKaKJfG`q98U8R;3dFPco{-ZJz09i2i6gm3@gzykvm{nrheW!|E9i&WE^jna6r%Fu$wTR&sjGinvNeU(`FLKAB{r1NV7t>#$A|>@Uh~azcu8 zK_;`N&SrQjx$0kK)FL7)`Tgdqne_0}>y_^(8|;bS+kAWrC=JFGAVuR_DQLT0A;L&5 zs1OMHke1zA=$1w7eS{;KLfKo1_di?-x+T1wMtO)t`_kPp)E;_;^`)OSQ2TcJJ4Bx#tbNFD z`mF^GDwWj zL{s0{okrGe_4-}wn_ga5JmyD&e-bAi;Z;cJA0M*^aL5k>mQcsplZaL+yc{FWXCG~kXJAg?EOB4KEgk^ev|;Alv9a4K{CgrUZLa@@4%%h zc#>W1Ceujsllc4YQ#e(}VI2&CLfqSseAGVS`ZiC>Y#4uG_be;>Birj<7j1rLCFM9z z{5=;^?>rs*GXS?=)Tuo&6Uyvd^0`Q+3E`5wEqBzfB*P_ikr9W*Z((8zym?~BB4M5MJ|o|OSg#!w zY*0Q;;FM#dS1eT2k9}%{PZ+<-`l0`#>m~VN*OXFyPfdWaz@CNBxo7@GpG%`5hw$$U zmx|B))v~6xJk{IQ7(P01>*lm<%{`!_zUm}b?%S3Me_h&ocr2QOEzUL^a?!S`vhvxAy- zeY0WcFQa~1_lwGCX;=rulSoyki#r;iQ0I%gl@3%VCsulRn`T`6DdKm_Eh0PVl3cIR zqh5jgkgA@_swCL#zOJT(9##9~o4XJ1W%v(=zWFVn z?|oJL+uZl=uM)Sq@_rh~6is|;ikWwM+4}U(8Nn$E0%Nc@pmjmdAKYIyGK>P`lm4BS zsflr31M}N8wwCL?l$D_ge7-NqIs>mM%%!;Q*9S@hy&(d?c8;iNN+`M?WcNP5PNmdx zvVqN6R3j7jeO(GIuRj(oqq`@q6RZ=4gF(s5+atWqa{p}iGRavZe@V=w36=JUxzn|b ziq14vBYwr1<`Zl1`y^#xY&2@!+>t+l&BBXE-}2g)f137;-2700OyI35_tuQX?H6}K z#2AjBhIO)HhlOB%-Dv$XcRli=IlFv{MEvIY@u0?&xFR?7JfFs;WNNaXUua+5Ps|Dd z0|`oAD#y_Jg;e?Fle-<=1Z`wub*z6+*eB6H9(M>^F*|87(w#$UGuDovE$jrBHU|UQ5v8P4IhwA72#F6A?LRc^NJkFe9th za`1?m`x`UvCO7g!a*>azH{$-2;F1$kG9WK9lER1l!po`Xd-pN?A&Ig1a;Tw0Ny_YJ zof#b?HFiih)>-X7iK&{;6rd-777=DK9o&0mDO%1>PGWfr8kaF|i4%Q{EHwGDR6NZ5 z_*E*G2&N=?njyI-;1g()NA4l&$Un=zOc4XIH>sRrjwoSOLyLjTnx8Xb9sOsCbd52c zw!gzVXc|HEOX(3mG+`sNgb%f^W5EaB##Nau|D~d9M&V*@;u}{8Ia6_xpbSP%7&6_c zd&p}=-(P2>c6wFPDcDNM%3Sf%-G@*!+=sU$c6Cf zpJBmQVj+|8hURA|D8r^U|&<+n}4BsMoz^uO6x6zf#fQxUFb|L5W$MT@Ym;r5C{lGY2(t-z#(sK(4 z&p5ox;DiLN8$l&rax>G`p`+aqJZb_M$kXHclFgy-b12}?z|f=@=kZQ!X3bl&HYQ!t<))*bL$BpIG75CAhFhBv}xt9@Gcd~nv*gQ zzM^Z!;;s6+BEf>ga*@+)i7eq-Z487^VXlW5QkoO_4lTmiRe`q+XW6eYyM#0vr7)=8 zag^EaP zWkAd)t*y%$)vV#zOUKDGO3HS*iWSyL!Q?K~OWQaiGzd#qen~;ewAo=RdCpYN=ogz{ z#t)~Fu=UI^{MJic@;?A^fB``yZu~o1b4lInzg$>0+I`dUXD;3VFZM0Ha8s(+xf=$1 zI>vF*$06SVb-fUfJH&EqqR&k>}EZdwlDoGhdZnj7J`zjgWtCeWKReHFTok56a8A! zxTo#wRDZaY2-UtoA~`hHmWX=8F%!X~UWw`)nShv_#?EknL7{ z9$#^jv{quu3H$^xm{X1zI{zag@9oYZj=-Pc@3WkLcmI}|P^*xAXZXnd!->YOJ0U#0 zX;48gx!){`Qm_RB=xZ;-$sPIlu}U(x^S+7bmBNk>mscf}m7I<{ynZZPRc-@-N>UPf zH&L&)6nV9v*xH0-bsmehSFnbNKb2hEB|b8tFBxC*~-nv(-}<*UdG$K#Sd5oxK*B-~+9 z)Hv-~t5gH`9oWjjZ%R zG0ISE|3u46NS0w@*sX7;?(=^Sc)vRqu|(!s_ckf;1Q+YAH!}W#5ZINHf~HZF9~*N- z3~R&W_?4c>dH&x&PLf2@iUuXaADBa&RfXrBKf5-c!-l{ojAI3Cd+;2hlF{-)&ZOlM zyg}<2)_BR%8HZgvZ|YX;T+MBV)UwMA*B=ZT0KfsJKg9oynnVXa9fWtQuVv|6qB@RI zV)20wt3^|wD~Xntm<@UmvyPKLfiahj0ds0uPTf1*CCKYwp6vbX)Vx%4ky`%9&D zaA`y?V|<>`ay+NIQzCpvO6ah#^yg7O-^wN8x~#3QVf;G<^^Y;?om}pIZ1GZ^HJNx^ z7vmCUcmsfxq#%&G9sI6|4b(Zp_w?S71m`gYw{wtuqPluExRPSYLYct4H1UrGF7}SW zs_lM25jeq6=MixPOii_4j*Hio;68|d#9a|ZbW%dPK7-zE#3%XMy;{;Aq*VY=fXxcY zii{&>0lrtA!A!2tn4B%{nDX03>Uhqn*YB^3Pu>5=tCIBYr=gTLtP_N?7SujFAW?Zh zP*2E)L5PJRLC6yX*>NW(GCu5Td?ri}2v0igN1Xm6FeYYI<#HiYy_I)T?oMObw3P00l4NM=Wy}^0D;zu9oe&6S%=AE9xFqaI2xQh%l z$svh>>>9KjcsW;f#o2dvcr{<^ioi)$_@puDeUG;7xb9NsZB20(C@GQy21dlJy{SZi z*?vy{Ft2}rYyRgy2R{In=oYgr@)?XO#;U)GBjM~Kl2LG?)K;eUi@O*Hc>^^=&CH=a z_z_w_F5=z$mr|oTSFY*R%kT8Z3_8TMdYqS7PV}byOaX-gI2I{s97jqv!JZp*jW&qS z{B8NW_o(dN>(NWQ1UfDNY~O*ZkiT-Ur+F zK*jZ(l69yVRi19>54pxGj4V=*Bn`wRRxz$JG>pq}UqIKRXPisUd_Dd-tJ8X3=z3)S?Gn{;Vaz<`(6AlARzu^+f1WSTkFD%hKhJt=Ds}@aS20Y?4+}a-pe<4u zaTF(D&=_K_{dms}aa5csExV;^8*+zK>!~|d1Fj9b(q#5A^W`c9i_7O#dJWg(}twPqD<>l@Vj@lv+yN4+)K;(6xPd%d0b~njBZ>=SJ z&tdTi$L*=Ru?jY=CX~@v`LX)u+_7YnPJ&(m>jIsX2kU~428#ge)Pl>mZyXzggb6xn z>%3)A&!-A(=#bD#HJzp0={>$%AQzq7`9$#UrxW7hIOF+kP7oS zpdQ|T4CXq~+zTX3)tz~2T178t z!~9uf_I#=stdoU)bkutvJ?eOG`o>bx z@8e0~!%SyALZ}aRlp~X#BFnG(Nm9Uwf^cEBnv6`H)9QM(r-^>Yi_$zQ2tZ28Kxr)s zzt$cF%+~7HUAP&HlIU;E=V!6CT5{7256SM#D{oXb5x1ssgZ_jL0T^X?AfNw!qdP5m zS)JLw=r$(p9PiRTWkB(A>QBARXr2Sz%Ua5*h&Uxe3L+^H$XFtb`juU1zvWx4Hm`!| zhV+eu`6W%k$H^CE)u)?N6vKLaS#(-eXZ7HNK-`BI%=97jMXWHNeF?=0igS7+u0_KUD6O#MDyEe6D4(*--CS?4hK|>IDD-q##JEK+ZR`B0PJ~z4~Wc zn-F0arp~3oxwN#udwx>de8E9uYvs;1%kBHXOGp5TkOu~!A5yY+X__p>IR+-~V2go^ zdjav@)#D*gwq@@M^xg|FN$r7kB0$-Q0&FculUZ2RHKI5Sam?fC{o9g@9uV^OteXm( zhLWc&5KpVKm4JeQC=3jrIk>-fpV9uRNc~miJ7m@Ul^;4L*cmh#WlW{UY=fLPyX;i6 zMoG8Mz&fBkK@@0r7|`lQg6Y=S4BR$aEqR8E%X7V2*Wmc{`)nTz01WJWNWGrfKzNM)fkB zYGjkZ0?dhdjcF+GBV(m1)bc@-ePzYKiaIUM z$e{ZAOX00V;z~8kl|!VU7W89Kx%TV)7va!hfnEDs}Ws|+qW1n zwi_h~vq+CBXaN4uR1rlC|KBUWhI8q6uzv*C(=ptv_|q^WxA&S0YJ0`zq}+iM3?i3fpIr1=XB`L8ZCA%&5v-iT}a9|Mky>4Hw5eESY{h zDYEoS>vXpXcqzdrx#%0Il&sn>~VNyqeMXIq|}Y|8xdr#j+|Buda-_*RUA# zu3A>sIa@bk6J5?AaBBF#S|G}MAPKGXE&fI{u_}F&2_|6)Wwq>&+AUczpLc!pd}KNNz75IZ_-j&MC1 zbEkH~`r#KA_NN>Z$H!<4_Xcjn7H#plsp|ZDWR-7dsx$`Z7X}R=ti>OGksZFy@rCj4 zxKX#poGuzui7>kBT-9wk9hH;m`W%A#RU~9@D6oXZXhwt3wV&*_HmdF!z4tL^jA)MT z$Jvtql=a{w&1fGf8&>{F^=}X?1ZXFKMAQ0W(MHh2h+|5uDmvNL;uvd_ivPrv9)(Iq z8ymCSo7FE*N5#QQ5{9%9(&p%viC!n=sGcJ&9!E0~Oq|@tF=ViQ^utp%-$QT` zUINM{WmKYiOhD?3?a#Cp7_JGLXJVb5v64p;}yBT{u0xJ!I^{5-*T zd=iaB3YS%=>(!`DtN&c-xZ3{d>uqjvD~q|eyz2*p6#9>XKUhjl{IC(&YGB1G3W89od7@`><@`yPtT!M!%X8Vj_|i)q^~YK?(}9A`t7o`;N3u7 z|CfH157&k22B-!}S!lyVsk8E+GqMPM5*S^5-35wBpn6ak zVUBD*I!85eq-s!r1yd{!i}U~Hp<~!hIQdUV28ts~ zW_u*OSS!zCvI?)9eLpoC`=t7&^|<~#R1wMnN%ev9T5UzY?u#nVe%V;pp6PMF+syO) zQ^8qP6WlMRO6=t_Yn>`DbpHZ`1hOEcl6eFv&Vbh)a|Y7?oKa{w4JUUdo7tU46!t* zA{0RoKzAkj`phYZcnpQ=zv1D#x4F{T-uwIO4P8bEujyjug#>yn2PIf11&=dOc-pG2eu{iAhoDD#qi=H^-0_%9!>TJ4gV#( zGf}jG%6P*L{xgk_XO(W4RwV1b)nEyRn1P5Zhw^2@D^MwA8faX?{CHXMMNKjN{bc{2p^nB>PFt5HmS^=Qqr{-*OI3 zVQsO?dDpRg%X6nQG7N|nR8oZNGX$DRA_f_LlDU)8Wq^$VT4JOmV!R5i<2c5+ynHPp zBa;<1&3~J?kV`ydF)eqy^+B@#5rfG|y@#+4B3+10%Lf`oB!V>f?N7=t744plw@R9Z z5zWPfV)vzSLKN#}z{zme%hl{pr+VzIm^_)8 zKjW&R2o5t0a7>qhT0Eb(*SdeN9FiNIt7Uah(p9u*-4vDY96%SBP~y35tGaE&n7 z04Zgf8bB+pdNHl=47#T7_$-0$V+KEqp|L`lCxriTv!Ls;`;SO@7(MESHL6a(BIR|VcNq85purIQ7(OI|9G8nObg$vf4q#~9 z+U(je;SQg!`uM8i_OtoZ7CY*V6I1!B&ztrc!1$5J`5S>2@VWfFc52SfY23{IzH?n6 zeTDvuDRpUXAN7JQSSIj=>A^(pvoa%a?Ylo(N;Sz7Itasl5@J)-W^yF;Z+3KS4Ti*6a(z-*Y(GO|PX+bf(+g2{|6q zAk(KtK>+OyNSrHR8STcT&qbPwbiIFWKT(-pIyFZ512bacMsvYc4c}^|h6i^SDX>H& zX<7r(GiO+Kq#u&4uk<MFQ(Fjfx+1{^%1R*2st z?h@CR>qf4xVsjIGhHDayJnZ9F#f7f<#J*u4H1E5k`_vf-5cp}_+t9>j*H%A;;hnL6 zvm!`?(?0jKy*-AYNy=|fMQN4x#2YaNh!X=zQ6Zmh;XR4QX;dVH zANI8sfk^`$j1Wm=rl77F#6#qqhi4vzp!*fpdYdApug|5exI7G2?I{@l(R|f-%@n&I z-T+!q)c4|%crE-sJf82B9-4O}H-sNu$&UIwS3aNVfB*TF9tFM_8|~>OV^|0IK*SU# z98Kpi{o>Hd>#C8pdUv{nSvYhE-12rn^mi7;Ab-VAQ{9HnUxnf+;%3=;m=^TJ%S^pa{wtY!#;SpC zmmWuc{w`IOG{hriAn=WdeacU?7E$9p8!zBiH=gb;SDHpNeYSp{yU{0ENt5W!hzTS2 zF^HeZz|TVNd-cc*rrkVkF`!&3mK}8|!sq<3oI#%BiA>U}SZ$r(`lPj7e_)-sm>A;8 zwH-0Gc}MNdzV0TKIF?Opc|)E-EVYp0pP;l%P0$-PfxAhkARj9u1tVZl5OM}|6B5TP zd(MCLdPR1}lAruqR&OYkMq5tO?sKYZYhr41z66%}U^}7k4=GrR=|+1fW4N_Elu|zT zFPX^KR9|v>|BQ0V;Mxb;eE+kzMepCdE(PnPg%1gFKK?;#$+u_E%h|9zmD!NqBg?LP z-t^4PGs70|Wsz&a1>76ul3K71IQfx0_39CE;j^|i!(M^cPF$KVV~+{WTw;E|iz7Ns zv!@>{Tovq=1bJ~eF(}+b!cqt$9mwS(G0wD>=KYf$)V=~kg3Dw-u~K=6T144OFzRJ% z=zm|?55GWM80GMVhM~h*qBkc!;u`21Y*Lf5!~ATOohQ1QME2~ei9g9DuafWWhkK;q zA)wZMk3xGyV@u>2U(Z*+(ybu0X;&ojlykHv*-(R%-Vk$}MGRHG!7F!!VWixX!^G)-S_toW1lg%hc0_D`e z!$bp#Ym%owR7Ow*$Uxg5Kh3XAG@Jaj;2%Dr7&{!n%S93f9PMM`z7Hx|jg?dCwKgBn zQuJcLcK|aZ3Du>eiMjr&uf!^74Vnv1$xwaqX?Gj+J!Ut?&2&tjjj@#F&;5~Ur@O&iLd2v zpndA&7=_fW<2J;9pU+|CG}e3-@}<+E-0@NEBVl_84^H>b zyMFGCjaI~im{*{K2}?kZrok2MvFqn+*_n(kM5P*JZi(RgMQpxiCZo;VOT(kd7|@9Iu4&t5@z(`=(?8@FFx|Mq92%*-6$c9={&l5yJX6^RUr;BHQY+y{ zQERJK7fQeEjR~uZ8ef;vPseDMXjNx7x>2RwkR&m{KL+Lpc(z~?&%riFj?(QL)^C)~ zTg9tHd`Mq(k6owt^j4+Lk-euxlo5?tFkS>O0O;WkN0z;XQGW<{mb~TLJ*y~f6Fd5Q zDI&RN#_FupWQ8v_Yiqu*OnD}(RTI7Z@ z3aFA7M55OINZ$c`Z`Vwy!qVE9HJNB3kC$BNj#BaLF6Yh-N@D6sgYT;5mHPn~_#o;$ z-yDJbHiKn*+tu1o%fi4PsqBy=fGl3O@V*?4 z5sAxcJSu0XL@#R$GaD;?uWFlyW>(3=S!qF#Z9=Y(YDn8h@@_n)X!Om^PQ&_y_c-G( z82?zb{<>!@|E1C#JX;Z2At=T?5SRQdH2Q;?MDNdDTHeEVu5UJ}`5H{cDA4~cIhsNS zt0`8+(hLG2qEaxt0rj{Oe9+d5?$hZczl^${Z@n?t;=f@BzKSsy$)Szb+CIk3G<|x3(bv(^3sGm{@f>LN+uf?o&2bT4QJI3ycfs+Ls z`G>_Ut<`9+XQWS=$7E08VgU0f+m!N~L8i1zC$~&*zVH?o8X))>ArEb(GBm*{=--u~ zCUec&*vj$W;Ptx}X~xpnrHxg}R>`gJw5*;hM_pfq?*L&Ik_4;zhbFn+Fwf&3&S*lcTwwFmkNccv(Q1Iaz&%Ck zh%*rb3aaOfbGlj(o#sNL!oxwXULLP6Y&eBd(*B&$P5!uPqfNJ99TdzWKqMyRII4n6 z0SLe_8^B?+*Z5-a!SC7A3U~?y^m{iC#*-@o7or z*8`l59Yz);6dgW#miz;vhx>o#`I&>$_38a5(*BKYN*{wT0wP>*%16x?^>s+?KWh0g*1129c2N?i2+Hl`cU-0ck-5k&rG4Ns&}S1f;vWrAu16K|u0f z@IJhp^L^iS{akw=+50+cKkHe~teJae?wO%|KITr`AGM0>8YlCFyUzF5>(q~<+Hp_C zS?WwG+O+_1^))8fChjC{ef5tZ2npCj9FPN?1Y)I- z%59uurTaD$_V#vq_)P`9`;N6ZGv05d1Ai^iR##DcwgVa-#C|~Y5t!JG!ms?V%2W&6 z=>tT)^gc)Lj%z3%5-kiBTqB7;qxMgR-Dl4R785k)g~at}2(EI!e96`ert27qb+{e8 zScsU-tlJ{$09J&D%Pnf5%3VW zWdMAJ;mo0a`1?Ivcv6&B_u*E=-TU|7n}{=|9V%Qan9G-+r@iNQvwPSYSXwYY0-AB^ z-T}jzV4vQo(UOJ?x?7cq*2nkonbe2%{BKSRjLctSjMxdc7Hb0WAFj&+mDxe~^ZJCy>z_4V3tRr3K&{ieGrF!H-2uWq2-l|7SJ3$*m!AMJEL1 zH3fy&fA_M-e+AKZJE)(p1C^E#|D@FmCN4lcH4=~2hR%`$be&e24PWt_9{W=+iq04L z3%6)>9hi~mfps8s3t0$1sN*>}mP6}VL$_7rArCZLnQ$fp43gtlx2;w^%kn+S@v~iV zn7}$oP!S5dMH?UBnwuV{CDo+v`r0ejNL+nxJ__8_7of`swnX3WLNQk~pPAy_Zl?(vkEI+LbMD}gC6P47JJdCN2yhxht)uE8YV5nP@NEXy_1_gG**VY z7SH_tsPP4;R4R)Q#0b=8?hd?H3N~kmiU#X|N`=BY)rIiehvQ;7rB<6H99*SPrWmCC zM)i7JcX+P+dwWNh@a8C|F0c;3TnLZPeuuBK`@rK_BkC~7qkRL4DiqNf!Sopfw|A}sfQQq(~ulGO$yAqg<|YsSN$n|F}bVC{=4RhzSK)PFuUsfmvq_7lHi?Cto)|W%#Hi+z&c*w zK*5Z`a5nsws>(b`?(1qRMv8Dnoh2lG6JPX&oG6NI&dpknm{{|~0jvWbbAL1b^QFWf5 zpu%^S{Heak)gX^><*pT!5u*WwOj966pxpo%?h3nZ>sKSHiiNZAk-n*O{GRH_i(pLj zJu@E;ydRZfQGK`kt#a$Q~ znKqGa5B(r4@I!85gI&aM{#^v}&+a7xZ~&?jz%;!J zb+~s5wHJd?WvBq&``?xcZQEtt<63z{24WPxca z1iDW146#%~0ekzkvr-vqQ-G+s9FeaHjg9TaZB_TD;zjZOp7g`^;!2>pm( z{&M-}#nxdBRJFsXBnilu#_EJ^&|iKqPa~K&WnjwK6yYF`w(60)EqJ+gwd3Wu`remR z?lIVJLn=gUCY7T+s8Qw_jg(6_PF?C3F3$au%oqtZY6NECpe;_?(GOFV(m=5ncO#g&zi{174i_$}l!M71;Z2H>%66{@0%u`!2gk(f)r~Tjxg( z{E>12qtCNMI34TWd!33EdsigXSu$?<{)quPT%V=Ue0R8~R3efgT358Zch!V&CJnxUe(-KejCny}`xa zf5Z0P?vm~isKY0-RWV6WyEs?REJT|y(`;BeS8HFbvuBFrP})M$ zFs9o7%;!*Qfj^KthLIK@jq@@6!#tNz{IWNl##v5^A;|R`$4Eg*O|Kro>tgp&y=a3F}9^n3TsUCSeZ(Qsn(pP7* za<47ZdV6d0Vw>QIGs1V92Jbrde;2>iPjcoRH{QJAGp-bI>o>2FyqcES6h4}i4CKh} z=ED^jN`QFgeZ(%m(ce)YS9i|p{Y8H1oc7VzZ7x;YDZaA`1_~2^C@8*F=noAe07>)n zUH;!c7kmGPcYbs_dr@*?x^99#c9<3HA!!Ur7%KNabT1>2KX4+`wCT{gypfH`4Avi1 zLc6C*cLK?@m*b*-``PXKOX8`;#&%8+CEf(=FitM0=4fjPu0<_oeR;|`K9&B#FT<$* zlU{ps99yskZGMG%k2{}r!X4zkz<{dD<`7Fz69lj=Cbn6MC;3yy59rwyq>H(Xl}58> zg7-GvlT9Y+_*LX8&s`!=3kS0<-W70=13!k5P0Ks{+`mFe}N`mX)xhX7LHpWk{YwW_~@0mFbBkgOq$ z`?mrPuEG$t$3w&)-}=yW;2udPbnWa;YwqJdt@>Z1FJvBk?bQY@0~oddGrEg~@Z%(k z+R=VMSosrw-e8xcrr~v`=h)DX`hv!(vjRlhbm7GF7$Qi4!LVvmGaQs5=&HnrF_hU? zFgHnX2+d%im)Ji-C2Rh2SV8ch93|!mkjf;93KQU|W<@On-tR5)zDT(0W(oNt6T(`m z?=vUSl+v1%m_455o_j(v;22@b;Kx23OmrtKS6K2+_6gb9MYo_-DbTCN_|E;+_Q%TT z*yXy-PIT^KaDwx=IL4%_(i@DxQ#2C#ccCt6Ro>l+tQ1bwkJ`iz(OM@nBDT{|*nme0 z05Rwif3dFhst1KEz8Fo5t0j|rX_t<(kTnU-n}0}SCe6xU9QNHUr|6=e zVvElLX~8+5LKRO^)dF{(P41hpqcJT?Ap$bM(ww}YNcv)**-%9`5N9{S>A7gunUSX0 zsOJhenNmvE@5Rm!+udX_wIB^`l#0B-{FgpPr4O8w$+!8IWpxiP=@|}#+D$`BKKe-< zbvND+`=fM3k{}zAEkK%+1q19Z9yfH=QpeH{DY?C`gFj1$!qw|1I_oeym#9L;og7X! z8m7Sj z`j;Q@UZ7SrhZXSSB#V$*Fn(RZLXeFtiFLO`zQCQx_jQ7QGD6)D(&tD^j@KWo2)ydZ#3x9tW#laPd)-KTb8gwjyh!eA4;J2V( zi9UPk*ShMfmqa;^(@S~S_emQ@*sCQqP9r#Ez7B%Z1dVa{AT!|(qzp=++?Q3<5gZuS zt{~Uk!CVT`=MZ=taYtu6R-Jz!KJZ=t6Yw}mP(gEXDks0;mXW2$I2&#LjK?@@=iu?M zpC#iLtc?YfjQ8z!LSLUBF8YGUfkrhDbHhP_z(e66+DL`xh2Flzlk@#YZ?ccaUBgk$Y&@*<8sY80=Bs5i3g(L0 z6~McY0I@1a=hc9`IP_X?UKo0?+|Hd-$Bo~%c)UxR_;9{xspTvB0?uJTYUsCyWc&476o?2vFp^uj;3 zzLy=lcfnm7TULyiaqNXCQN6(z#4S>lzaXrX>N=Xt$?owVJTSGR@c*3l~ZfuTx-F-xIO4g(_^1I};c=yDrR!!-NbOF;4 zcy=%g^AU82hM+0yhaIF1rBOv&C!WyoWYwe=-zRsOa4Hj(pRvifZ?S{<4FH-#lGJ9dwh93!ni?-_6`ykbtTrNnVF0f{gA2%A`Uf;B^tk;f zVx6VBCZnxV8=jZjy0>|(rsqQ`Eto&*IN%?;Fv;TI0LdTd<9c6B%-v|*Vcq6Lk;OIk z^{*R`s$!QSV=eIb>C!>#bX~^*ryhU?36S%H$$G^n_{Y6XW@#7t(?6oSPKYs2HAfurx6t=yNbt7)7 zwWqUiFtyim1M4KXK-;&AyA@S`Irjh=%xNGb1As~ei71&6!Hp0(R{;t09J+vZg$S_z z>KzxYM0Ch3+Q`O|IoaqvbjIH(jG~#!8Rr$@ZCa`BC7ZL(!iL;~bH;kTuz@UKz@ey& zQ!z;_@zmQp#3Z#7?RFq(#U1{5_Y2D@>U?UW%wvZpR)`<7J2tC-@~u9X{; zez$_?=+MnVVBoty88|Qw2~fNQ3l&%R!<9pETkhhM+-|3h=3AW9v@GT2?4k=Z1k&AW z&qyM-*z-ZRElw~J7YYw}m&0#gWn{~YN81*L368g7uZwH0w*HK(;MdJUBvg%=Bju`} zU>&Hif^J{_89c;{V9R{{$;|Kq!#F{YO{ve&cqz4E|I@QR{O7?t0<56c=EgZ49rk_B z0Cx$}MK1$iHsNle#u@P+GN-vlQh(?h!+XSQy=3Q3hU;t&3=R?(7g2EsoCB5@L)J7{ zCp>$-f0-t|m%Whau_E!)l8IMevyn*$O+7;au94>EhoUlVP>ny(=#NaVg&b$$tyKS{ zUGrWy5KDO?{{<~z?YZI`ar`FI1CXr&g-)P*)rA~v`oiT->e1NH5bFG+xMa2HJ6cw< z9jSw+jgrcNhW8q8sS_w?f_0!W8Ug_2Dew%+w?=|CDKtX_?$$?t6wXwzoOCpw9m%FV zz25g}E`O1R5C9tiqOxolQ+LXXL5JZ4@ z$u(CqQ!QLcM_u{gVF4w&$e%kJ*nU=FdkGLOlCVmqe@@jOp0=TUe*ysAI}FdBoAhGcTgr9hHaTORaTjTUsk0L+-0` zt7O-^hHU`nK|vmzq(iGOoSTr4s=)uVCf_@Izqt#@`FB?dgJl zKYG~DlF&(zhK-g*fdcuQ~+HF(04ochvdl=BYl1)Oo^K@Rr_R60*p z>RHT4H?Gl5I#*`70WpyPDG~??wa&wj|E9mUd=j0M_B{8oUtw=!>b;W+Q$bfE6%l?m z%<^Bl5?~!44+q3(^1l)jEUpK+Xfste32qJ|U3;0579oeo>VL{UFJ;Z9k`~GWf?E;* z=s^{GQCAJa4Qu@t*ir6S&0(%izK_^VH~d~yug_kvrROq{M^fwn0OI-NKd3WJ{V*J{ z5pb*fFmy+$Et>Ijybtm`d1~-9wK{_{e77b3kdJn%46Ks@!B?1C@I8TB&9pOOR)QPy z6n1xV<2$^N!i*>RG`~xl&5}GF%z9*K`3qQ0@HB{K?>P;>uGd$cUmhv*XxCA*k2y1| zeoJaM-(VZmBG!Kr5Je_>T6G@$0yQeIYn}u#lz{qj%6-j5?7#nR3^OnFjLiUiDGm z->@ru0Ol5$O~?uig~In~84&a#;QHM`608$V{WnZVBFAXYiL-lU4m58hWk~%51a28X z4S<5|F`xt)f_x=r?i}Bk-AehN4-d}TzWw`^M0;Af&HRn$21*F3_C3(zOGfsxlS=Yc z%@xNNses-In)%Wh^b^ZrBSr)rR!KVUw8^pa`+X~7EEl*2;!Q38_d41j$-hIt6-v| zUaIXLZ|jDjAhpRHI#>rfm_f!dsSFcV=t+y@CQT#`z=Jq$P&xvL!y+MLBB4?tAfO@n zo^uT^q8_lqKb^-5K04Ypx?Q@CEr*4rLid|@En<1HS04r%-%LfYpuCLO7^pf(+!d20 zpO4JMK6J+nd1PaQLcDnGQ)sM=)4}TWS9~-;l!qzr)T?5ReCvdd|NOVUVQCE|o;;zC zwi9|C^?D)uPqy{5jk*S8U7+-3z(gMywERMSBL#wx$nFNxD8~}ASWyQ z${^$s4gM_0322nO`M7g&>9NcoPhIKW@MFh7)gNzspZr%tqd@&UiQynAi^Yhyt$Pu4&ETMEz-2mJ$t5^SPQI+u(;*657 zJ$2k%3(h!oEK6JIiOHld{h^mL1OiO_pcyDkCZ?_;07Z35UlvOr@GU(QuB)CoA8te5C%8cO3u6j%uhWJ7{W z+l8VU8VLXp11VeRT!J7k4QR4r1{p(F#L~|N~vW(zdLXJB{-CyhPGdaqC5ge7B`nR#3MfKpZ!S_bJ*;eVsbC%ku5%A~H0gt_4se1H6y>w9K^z=s3;W9cV^9WlMzw`lP(c)&!C%MgxF8vI~riZmn* zyZ22B9gTm!^QGTAxZ&aC+MK`;<|0S*Mdp_(c%U@sjthIB|1q3zW+`ryPV;OkT($aa zZ;UNw@sYWr&@wf5i)uwTinM3hc@`XGQK6|(t5tC1AtxpLD*wcBeZx^_ePBnB8FP-k z)7G28(VX)D{hp&Jh^zBT3$R1!*RNM0DyfKjRL`cL|4b9>-)5Q@oc2+U;NoS%{;fS( zyn$Wv#^hWXaPV-zAjAL^odzEedy2l{2e;_Zjl#( zAoRm=$=*xNf~#uG8XAQ@c8{ zd(~9NtWh+LG&L1LE^%{Q2_&Vk52h^ zD;24}BtB;0(l5th4yF%chw%v* zq67OxL=3Lg2-TrAOIeWFR%%95j|u#XUBPoE?qVISnfi(gASDT2K(e{GN4Z<@bGh5^ z^0MH&(km>b8XwQ0FFlsh*9c!NeWX)bDnc#uz6tzZ(36A*D$VK*g0Jh)-gk~9WA0SD zU;J>rL)>!Q4R!b!gVM9}sB!-m($;UVPJru@+|xACi%hz>4CK|M4Jq=J0v{4$#sx5jg54_N3iaC>Sz zcOzw%0GU-v7PORsy`DETRSevQAI$$^UcLBJC;a&2u&Ez?14lYE@LPDBK_y?Hu_f2p zO#sZe1q2`_*H_Tv9rAl05Pwu7yYa6<`J-!x0a6X}L&{O_oaAip2l%umYf%UxpcY1& z=yMu8=ydd5@Z~;xSkYgz^z3~0KOK?-UrJxL1x#c-;1cl6=6nYjd7MP?&7_xNe8{s( z)AbEu=fg^Ri$DARC-O(5cPNys!h1-3m{pfQF#@Clig6+HlMChyKme|hS|Bwum4d2I z!g(%3o5H=?$(e%JidToLj6a5H;>fX^(9)34|q0=`VSHq+Mj zS<7X3X+@t#Un_shpA&DDSmIVWL-Xvb{2~_GQY6y+4?*~uyXQUIFMBb2LaiUc=TM#% zxmkcmy~39GIFe-WhJnBX#FjnHG|o~ap(ce%suiHrBtg?}7{Zx|hUz&llFLvvCj=5; zg9>$RT|HIlWRgMx$6A`6|GHf$;|y>aLF+h(Qk3M4{ojKMK`iP&el89fmIc>MGd;7hb3=^d*XTZWh{M$> zrQ3NgN&2x%*-pR2J>&Bww$YdSFv&=4ycRqu+M{aE`thYt`J2jRFAgr}xV9R;N#JdP z+{Ps}qi+>%;@Gp&`bINuZr)0NHV{RCOYC&at@pdgm-|y(DI%B2dwXzMKtvdF%D;cb zfeoYhFF+>#A3KM^GFTQ|w;(WgUnMqQJGSmPMBvNvSszPNU7c6t^6#=bqil?=%dIjfgqel5E4Y*4$Bz}FM}I)W zZv0lsIMM$1ClaHxbe-bC+>aR}%2J>;k0c;#K#p^F-endXzFR8zZ{U}UBZoM};K`zt`1@wGgFSg5DL}v=KXL_3`MsDS zdU+MW_W%3mV&^dDL(i~n)XOn|9P$3#+9D3NA>q3W4NnsS;;5`y)(I9;+smuzaX=ps zu`GNtmuYRRq}whaD1hqu@Gb*n9n==-s&D=1XbGbuO>r|LSPuJZKCmlwnrs7pTaA=q>3V9LDMF{@Ts;#G*Kl8o0QzI;L&Bm~LDD>wUof zeiBHF6lg#V^-Ku{69_Mk{l6|KeCwAEDy-MHKE_Avuv;NV8;arFhM794xBd}-wPQ}4 zIr~ao$1x(@bGd`t$yrbHRuahXT6Q#3+7;}Kq*wK6ZJjCUWev-gme`m9m=EF{5SlGp zg2Til0t`_D2a)LbhjLX%KZQu9z4x@9uI^$gPj8TP<~M^HML^5}Q@t)=#$E_6Iteg9 zc;e7*;cswp);Sj4)IhI#D6l*a=KDfzM)Aha1?0lPbnwgW*2N#;$m;Vb4c74!wH{NEzF*PD4g87GU(}jcKc7kld-46! zFh&IHKvy#;)I8P;57i%jsv^&=zfQ^~b&+6LA~yx7YLp;K z7>4&`z;Bi+y|&Swp`|-+s{LM^72%$+BOOcq`s8uBIE6Wf<+&#du0Bjfr(Vr8d?AzF zkQ%H``c)~ZK_O(Ar}l$|UJ}o`;Og2AN@EW2>_Aha^RavvA`k)E$U6(F zfb6Ag-Pqdgo82qE$NgdToP2)7hrQ_i}Sf zvcm^uaKOG_m@V~UzFc2AJdyR9$!z`EcF5w5@@~4t^v8baNs==mf3rPLu0GN zCMrO2-z-0DnSrw-Ceh_3;`*a;T;qUq<_IX~yZCCo3-HIC;5kza#sng%3HZNA%EV~o za#gU{md0R;HzRAFQVsz$RvusuAwR7@8@3KWr)$5erR0UG-ffd^l6Buh&8w4J3|M3_ zGv_~BzPHDCkbDjR&dUxjo;PuoC3ZM^r*XUP1I3O!U5_<-6A6p_k<~Z%7)DI7>qJ}w z^?2w0B$ycp`wZjZ@aN43e4~{TydN~@iV0jc z*!yKdIGSAb!DNx>pxR48l{Pydqv3XH;#R%WQX`0e@#WX~<7(7EYq{Mw|H+5kWSbnk&`1%kfAqh>gN_7UD{ zm#|fzzDeDsH(>g#Hg_18mf^UKx{APlY60khU}WIs=*-%yX5Cy*{-}Qy9I;>iQ+C8c z$0OQ4Ll~ydlF=L!@MfWhM;|111SCKYW7zv0F2cq0j~5302BBR6p*|YAONz2@&YjlH z;;okgZ^h~N9CgP*c^Bwu%MbaXakFso{A`a--B+%qw@rh3ZPrzs@C&8O18VC-RqMhd z1+lpaPy!;b&INo2t@Mly?1r?%0Rp$9Zw@$%Dt0f;-;z=In*ZP__Ihs93)X?wm{4D% zJg8_Mdp%z^ zO4QU{4ZR@>Z~ayyqb;dBLo@i=l=9yDN%x)}VU5iAPyHp2DVG2o0}RDW^IQX6Kkyki zHfz0o?$gYbSOU;sf{H(NJ_voNB! zfv9z^lB!7juL%_i<5_8|m2jOBN2t{GNw5x-Gw9U!1RdTHV8dpCM7uoY>`7nM%Hq;9OoF}G}J2p*!yDO(|IjeM6_IhU^Z>zH6 zsVTRVSETF-z5M2(+Nivh6ueOHj4J555mW^ zH4ddRt{3MbmMPG^Yw*i;tLP#HIRXiOU;tp&_iqU-UJ4G{4Os>)>6rC%VS`ei-dSA9 z-H&Zv&yW0cn6~X=t$7Bj@G&I7J-M9X`o$d&=Aocm0-*o;^J3qy`Ss#=w7Z6yGR+yM z7sBKOk#OJ5;mz^<@L=in9JL5ZpbWf3Lwwvsv+lC5i?*~WpHkdxtgG&&+ruqtYYYy2 znU?F^#CeYML3siUDo-}U^}-3+s*!PWfx-25JkHNUH&dGRQlf~cn?t+`+pt1T(E-{3 z)!qD%3!bon4Vzyt4z>%&^sr{@;*V6rUfgof&xqL$qxkNf6HxWa>3)OQUF+`(=Ja#l zOfDr0Cyxp-cXqi0ql2~zmCxLjiyI}2lrzLD(Kh8FVm(hCxB-BY2GNvaLg0$_&Gc&% zlLU-WF8doi{b`{c$41s?c7*ljdX}CV{7-`&!3~fFiE!AB%WB7lHCuQ4pFs0}pL6O3 zOcoC(Iklw`6;-R^dBS5EPrTRkwB{gty1a3PGU4??obToK|NfZ7FNtM*pf1&nG%gUg zcVDAY1~<=v!N7>tduL452Ane}7Kcg@+pfxaC-*px-Xbcqh{g^S^WY*(sHlDCN4#e# zfqI9_HKWFe9>5sDEQM&?_4`=p*Z|n0P$9TMjuXu56K^)LnbH4~M2FaHox%MtyYKx% zkuC<=3F}8TR~inUiA!nF_;HP7KPv$li%kaYiTs)mT`9t_zq;&@po@{t-y-)NV9jI& zE=LUJhr_Ms&9*yOV)bL8rF0(SpV}B&gAUB6@3st9N>plAi$;ZEgO4K%_y#a3>OaGU zd3|7y7eAMOLjQR2$Au`vVqX&Sb}@fz9(Qk3D>%AFy!)FFGHm6ueeY}?@3`|if?w?A z=J{Kr3&?*nVu=Z`wXhqvCzNLoBu994E{LvEwbI_sCIgTNP<|lOzf}O=JTDJ6g8@1d zfAFJ0ZERG=e8x?k(6FJxjVRh?WU2h(ii?;CKNM=MAHqey1&$aCMD4DAE_S<2cuv5U z2v2X|RSHNbx)Wj%*hZ56fDgMF&u!mri(!e_-{;5tC+_d=v8O0{iNTNLjh20LCY>cUbz5bzoFqg;J?q6Jg%9AqgB;(WaB4etgA*MIla;N ze9Y%&(;<0NNb?q0$IS^EW?rnT?S$V0#PaI8DlSVT@n9nV_a+o?N9f-t#DyVf{@_M_ zlP7Az1_TgPWkG`EdDUACm#a-nZ-0NZ-s|m;=UG{@pHZIHF*SVO!e)x6(HxD!00IbL z5ya5Qgu2WF#r8)dSBY3x;LVJj$Gn?k-G=yP@Vk~ul0oLSuZq$^zO7&#Ajms4 zba_7A#wK;j?0ZQ5a%5VHEbEiM^_Q)d0dP^c&eNW-d*0~}KbM)RYU|QAzt!B+wj)U{R>dg z0kK`Z;SuxyZ+*=9Z1?a0coUhY4;n4j4yprYN)nyqOZ{$H$C4RpIc(=?xF9b2v0yKP z=bQsK*mLrZ;0WclYy1|!4EGV|`xxUfN8t%RZiats`JU3|A=9sRe9-|Di(3*T;$Q)z zoHE$?gYW(I_l9S9g2fJzseP}7qv$(Y#esrhW1HWEH;qK%MC||<0SMP60kbF*?pC7; zXLa4l*L-nYx!35gQ6%vtA+6Rt8oTtpk;~tzj7O-T+nNATM?9QP`aFzgKz%H(_|WJp zDs_wG$~KZ-*yynrjik()k(=_^%td#$+GaR=cb)rj$RW<2x(~Km-)!9?5hiyEV>xAQ z{*(HA5}kK9&STS(z~6_RLnbuM1-uWL-hn>P5cZ)LqX9ogq+;CXdeXKTz()V>rSqmCcnZ{ad(Sy>5etK_VT}nOD1Vx z9Tz7bUCOVeKIo9_%x8R(9bFZl9JwKy}EDgRPTZ?@yT458U^T_}t+WBSA#|&Mpo4!h5f6p_F7x6B_E;o9Y*Az%?w$JpH8Z9>GfTFfz&$4`8HjJR{Q zv({E{A{`sW0rI;7k^=0I!QHzWewM@T5zS$AH`o8&NXWW~b~_dOwBZ@OOfOS`4{zTD zQ3n8WfY=WOFc&|;pI6O6+a*w1pDG+*#2?u=w6@#YAcrc)_ad}T!hxs#d_1TG_zqBy z$?{hCI#c{qf^3FYVafA_opq^NhUhoaDIQY(kkVRJR;)O-vjFP=lM1o}lN)gP|2yHB z;_tv4Y9^-Spo!}niRE>z?V4rfqvplER=RC(K);rdBnp^@_nO#b-a586?*BH@&k4F3 z1sre(g$6s|1{p=(&`HKUB=iK&kp}7!rsvvy;oqBvF%3beELQ%WwC`e7ja^(2?u}C% zx>p}e&2chgv-E<2Lk9YyLY~eXkS{2#$ts%yT z%^;QaAiIgI*ve{DT)&^w7%?Rk>^y$7!v@?x5PgB6{a>J%8oK28&on-nq+`62%F}+= zxxO{^_fK=EOXBhA9ovsY?Bh-#2nLeYVCw0`B?ym%zg_9~YqvMM8$NfK4u606Dhumb zJ?6%U#|lz;iM@5pEs<(KQkT9Yf2=_j`{0gWJI%GVXjs~n4*P31@r=5$waD8Ug?Dgh zDL6zeC2$3VEYD#Xq{BL|Y^hgw%GkR^#gjR?9tv&BFV{keW9&b-qTtEhp|eVPlMU#0 zpi|!Eq_o0nxK44`t_oGvXD>u0B9{)7n@vfMqJ0wXMa6NjF)F%)bT8%D2m1M^xQcGqoQFkvx=*V3?o6hR_jx_-4@s5tTpm>;h#534wZ*)?1gYe zDbaolV!Cin*&)urR=}lmO3RLr1l$iKF2+PO-cTXHfo{yh=}s+%_Y_x<}VdqM{5AIYSyJTwHJKv zg{+KJHgqGx>+uRv-hBem11@PW0Tqfmbi(hx_7l1ALow`E%FMJX!y)6+RerCJn^S&o zh}=$gcJ7b{$QZ=7E?Z;G<>8=H0AzggKY=musbN1CyM~eVBvIlrM7lf1+*!YFyjesS z_@=-}jYB_hq=|y{OfW$ZjzmU?8;oVSObZ^JD3#K%Wt4d^FETvUjK}-ZF=*J1D7p{u z{CWRG*s*`#gEN9$OYr{QmGt!!nyOUEFUK-=C?+mf)3rt@eE!UX*9zkmSSJmpP{Q7J zwGZmjf9DF#!%|K#&qRMj z546)zL?@}b=@~@tYHpZ{ViBfJEX|xa4DAGoDyhq!Nhc||=)^#lasTUt zfnZ;V@fgOrqbC^?!;>r854gc=-!c=@Z9ioG){(!VZp^3~K6o^^0-N6ezOXIriLsL- ze+PeCh##VIYIdAk1Ya1|ei%}Ev%?SW&x*id1D)C-?eQ66MuGpnZYE)$TAD^H`W%UF%)xpT9x~__njP8B7f%TRx=nj z^pN;BsdBlwNZLCtmV(O;=9ELE;JgsHBnD2K^(8ROk_Encw=Z5Fq(E*whw;_BPV_8V z%kr({a4Z1upy~`_aGgR-GqBGWdn_~&n}<#%KYc$fzEjq)6^Y89YwMD-5ZbQOIn)MJ46m;DY^PoxIyHJ8xX%BuKSNPxH6+< z+9os~Av;zQu^7HlIL-2Cy6`QBY2IDTeQb$J#HRBEjVy>v!uENZ1b3i>ZT8+OO}*b+ zA?EM)+Elxy#6~3i&HcB;I5$dVlCIL~MXl{jJsfBm_f>yX^3dzwK?2n8>gh`>v<7Jlc_*s7C9o1aYM zH^}<9a@wPE#E5N$-O4F@D&Q0wVYMAVoe46vfWZdyXFeUkac#hD%lPZ<&PPuL!AQkVsJA5Hpku)3YfI>%9!H({%Z{_ik!f=%pS zilAy_{<*CJZ4zLgH}*3eTIILJ@b+8}7QxmZ5{&VX!rLVN<5#YC$imc?9?RELtO+VY zK)YQSA{&{3Z4*517W0E4q{pTo{{Fb%8M17A5{WA$mBTR>hN3FA)e&guea_GTQ&M1$ z^MUxBU>)Z&p^FL`hp@sV61ynR!p4{l-#D823$>8~zZg>0DDZkxz)glKs%JnU);Zt= zQlETK72F@P@bi;kQ&<+C|374`5`SmRQX=u7x0v@&0sx$rk`aKS4PWZuLhs~OIb#-1 zPW|m)byt;W4%ctLzK#ToU(cVOq&WsC3jxZJG#~>)H07l!cy!| z?xsUCO!3gD5X9wxPIp5_z@-rfv1n;D1ot}d3)T5w7s`G7Vj_W*-U;W6dIz=aGSwGW zKa|=CUh11!x|u%Y>q{;B#?gCnY4$&MGQ2BVr>mh}U!^27K^)Aa-gj^NLTw@Lg-%h8 zf(Vo?5LHl7bfKirz)V`m5hzNdaCW*gj$(-ypsA4eM7TTME0I^$StOQ`h zK)L`*`wle1*BuvOjB`~UJ7mrtoQ_H1S>tP(QvWrKM}A~e`onXWYZt5oUL2GjO9W#^ zAb*8fCVWB6M9Q3;_ZN9L(GZMq#J>>)?6Hbh3@f;^zXT`@dI*=A}xt&VzWMJP~GtT6*B?3g)xzoXj_0&&?ba zX4^mA70eC5#91j{tPHuI?$u^B57vRM0g#_ll?nf>VJ<-KKT5`J@VbgbEfx@E z*L>MxGttSC*3|K zTzJnvjvc_7|t#T)7Xvy%XMO&a4KPml-F*R_K7yI)9HO&yH91Fab`4yS}0}C$> zQ5tOnW#0qbPm=c6KlQCi`npv}9fNf;=gq1v)}27SN}yz%GPm-M`T7=>r!W|Yg`3or z?=5LRPR=qPmwj%K_iG1mEx6Ca|FF;P;{jKODaH|dMEcjWng}WN^*?s}36r`19Zh1t zuGymRIUS|0GC8!HwRp>p2PuDc%IC{g+h7%N_^Llh^}hZ<3Gp6=qG&ZQh+Rnm zmO3mp7kouhpWP%5u-jETA-ebaI>~qS-NYw#Ca1>LJ)3v#XiAuS-#RB1@Ulb2#5Emo zoAl5E5B(@x`Onn)zD{fge{O`M$yuZB!^p-Lndpsr0@&xVBv3;EdtU8TOb^E-THCj3 zi^yf=F3x6q#ynO#>6*PsLsN8$fq3%Sst&M8pjH&p4kuRwf*qVU@$Ob=jN%XpEbVk% zW6x9@eB5s!r9)V&v7I<63FJ!x^pAv!SsI4m`%JPuTBw@AdNS%-C87SiEF5L{#p<9z zi$_}Ly=Jvl766SUIe=KgzI*E#d|d?RsQ5p+EsRK8)MBxqcQ;PZ=JUGDt3>6L^12s} z*Bik)KzxH*+2ntNe|K|@ftduW2j!SF(?({G(i8}~yQy-qHKlKbS1FG^^$q~*qG$nMWi{>FZi2U#t?iy_XjBE065y z6pqMe?brYhVI#m!=Oyz02`>{xiRTMGP~uOr9rdV?T1C=3sqcIG4_^rHOD)-+mVS!_ zcn)Z}3kAu#a^U+59@y?JY)HXb(;}}LlGDwx|CWS6pP+FDlqUl37G~r=bi>uq$Yg;d9;MS4 z`AP|Lvv=cY$be3`6!tm@QPQH5bNaZ54q7t_dd82Ks@3bQcGR|+ zLs%k8rd;<`hk<4V<{r{m;hAs=xk*oTw$vMkLlji%96s+i$;cCuDmNRQ>`GxR+!*~! z2xvM$ZHHKTU(c{$QyImfJyTun{bJ9V7mmI3sH9(FDM7c6U>|em(@8b;n1)pow)0$*6+uH8Qvv*&Czx7nKaH$y-Wa;laKBm$mqxaH*G(&7KjuUz{(%t>~h6hhy0J z226gXHXOo|bV8FH{)I2$r?#G;L%8)a3h`f&wf}L}Fv*s=&2jh6#@gUy zta@JO){BnSv-uA}nq=V&Z;V4rMk|Uh<)djW=>fvi+dF5$xn5#Vb=2>r{&;%$>aZfk zQS_E7Q*hGx{sH`iS^9lY0Sp1HHf7hxJcH)%$d09mg}WO$V?>7KeXH4T6ydA-Jn0ea z1#XD!CHpLC1*%|hgONV2HVpsmLP}sf5SjK{&pp0|zCU=WT7ubCG2jPMec(cg}-MGxOA-0TE9=K>8NVLOkn zf!|5=@~HyWoUFytRDrTDZ+lH5@V7ecA92|FaNgTPhW6hwE)6sTGr-MHk<}t6g?vZmbCn{L>v-K*gm0$%G=`wxuYlpRC+* zWbnpAS`D}yfSz>OkI4UO$M`gKe>Hy-ragP*Ruo{cHlJ@uL4=~Di*c8jWMDA4JPf!h zU`!9R zPV3e5wN{Iay(c2`^Y*!K!wGV{7e;%h34R_CVg{s2bD~f50z)Kx`=lSrs;e9-v`y0; z-E36n**&E!wK-%O}g3z^EJCZy3oLOB2d z1Ex;{AYubJm#0TlKX+ws4{WmJt6QKb_i2nwVhdOgpLxx$BFb9+0L)bGa|R!bNqM{s zznChtr*&2bL{%a^p0sZc2+$djNQ?Gs2zFi{TgXd`{H6ozK#lF)TCm4uQH=57 z9F1kXyJ=irXcnfp8fqNUif`oP^zmE26v)beZpI)td~u#VSC!2&{X3c_9EYE|i%Qo8 zvmMa(WwgU{GfQ%x$t9M&wJ=0Ew--Eokm{?uVv5ei;WgiN67f57mfgS3G9oVji_QN1 zgU5J@`$*}UJqH_LofII-!9Za=RA>y&CFBsJPIGY1=Itw{?{@ZiBoSeX!V4C}xL(_n zFQN)G#=$z!VG3euhh4=hDgJ~GOp>>EuQDbTk{qdyr$_ruOQZik!rnWa>;L;7w<;?u z6|&0+*)!Rrgi0zqMP-&EA!R3fkI3F5TS8XKNcPN3_ROB4-|>7tJiR~f_jUcg{n5*- z%efx+aqj2b&R!mncjfpL9N^#r{y>n>h@dO|jM0Y@4_4fo&N^^9WE^F+6d{z1t=?j+ zZJCxoeyQ5%3eHgo+JIXg!d$3xN$$lY^keU-_q%?y`Sm(7w}p?Jue|-PQe7si-G}Xq zSMHm)_xZtCIbo{49L)Ra@tn!}DH&SGAKI^buJH}lEvjeVcZOe460-2zoS(4r1tSc` zry&kL_e{+C)9tN^FH%w`Ae(D@A8hwoDt({Ah$WEms@G~or6i>3=HK=T)<>N8d% zA8^@1LQ4z1RUFzD?is4G&v1<7G(>6K^w}+3x(akK&=oO;gCN5fanW4-#5Ll&5cTrQ z>9<&TA9P7tr*anqUk6v74VcDf!oJiEbYRjV(YtSl#?4w+l|x!o_-)}2R(>o?mkTBE z8A4{~>)M60On7izz{tQ6Q>6O0gD#AK^#xxw;&tDSIg@rPNb1O)?8v)Ui^9JC%$?S6 z;~ENc}uZ)`f$o_0r3rSU$CpSa8H!-TPc?^3{ znh?hPdvv_!Wec+*H%W>~0wvC;;j8`hYrl0a2UOIAmjx!6I;Nj03k~{|Z!lL=jx6NG@@G*_pY5L!X?R$HhVT zOmn{88IT+=v~fm1GuIph$ze0?;|4qz7@p>I0t?$o8lO=V3!8+I>=@QLMlAHuG;}fQ z<)6OR&V-L#KLx+&@9d*JQE<|T1BYEAS~(&S}gE~V8`(|`e3 zya)3HT$eEdq`X?)gF8ngv@4og5OxgKFXA03m>?l! zf=C|K|6peX8==-cfdc=Rg+8*CUaCHA-Fe@~jz3_dr1Uy}r|b~5mFB|<0!8hFgCiGV ze^Xv}{#C8r#N6|(>&wvNF_5Z9v6DXAxNdfOJ(CI$imWIvQiD<7i($3C$fwe$Lh(#9 zQuW4e7e+-fczOP-GL*Hs)5RRgb%_roA7DRGqzmgXqRBynY|B4lC+wta!W}=_;pQfB zrGG^QwD5EP|_Jpa0S^3GGNFA)UF$=;hR?h<+5${}Vo}+VDp`-21j~CmEI|})e^e|IPj`bnd_Sb7e&HHH3KA=+U);7(*WJ+ z`*P-%_Urp6I!uacO()5lv0hY*Fpjl5klJh1D{a2&h(j#_u9?_fj^*Y1%~e`&)r)-B z88wf(sxjSY(q?~6+`f9sVb~KCqawt6(Tbo83JekNjB=6j7pm>n`nk7qF2eIRmALQD zE@tK54vM&Qt!>*T;o^RB5R|Z>^ngz|l0m?@f5@mmPRM@`|ARVqbQS28j_W#XFkt_J;(h^*fARTtdEo; zPncewisJVHR)MY)h}0fSz<9DuKE=872d&n$K2|nu3DZe{nGEZ_JWnx~FUB9<+Mi!e*J2HO7^htJo;drtA7_UD3_F(i>NRx z#z>aiE|@f2;h00)a*m4eV9J*k1v~aGu16p<_J`@BePKz5Rj1du9n*YB`GoX+qy-%W z@GZwf#!tFzpZ1~pBO)pw~?6of?(d(ov0^Sx}-PX#dAf}`nDxAtI;i)Z*T`dYGV zNY8laJ(q`0(FX2QuNDN%S z$;RddI>=Q(T*&j_%12OzIuRb*%EQKO!!ec+-W875gMB9m@?tqZy3W-QP2|sKLj(rA zFlaDR(uoljQdbG+Tt53+owoQiecaThgqA5m@CN(CAT!s~RWsg0`uhVQ_EP*yFUcLz3jsO^03aUg(8Fv}oE`qSsosY% zzwbQxbT*=2O*!F+sg87SXJc}_c(gm#4A8*{YB98tvg?5n54r5or9M-5mgmkgGpT#| z^mhocyWVflT^v&mtL+zy1CJhrQ=o+-id~Wqv!dlbin~xp-H|jIlEj`5;a$V}#G2W# z!0ne&F=`*>{GJKu6d-LIjS_0(Fz>>hd4r|;Uxv!re+<8c%7$hquj{hCHGUCPzgb{0 z>g@!sQ$ffg=0iNZxtMicPf21SFZx}klk%5x%~bDKvBKJdv#L~TaH~}yZMXG)+=1~xKQrgGFN?9W_3ovfLBto2T-;jtA$hzanP9yTw zC#Jpc-}SMG`om{o#q|XInFc-XDC=Y392j+UT3=70`)Z@FL8YgCtJBIC^b;s5iczY#9&kTK0E;r5HQ6JL1( z_8Wa4bgf-S+IGS+-EOp`G0Up`bkKOyrs12gBQ~;XCe_2M&#ZSufs<8b8&m+;ZU`## zM2-dMLWj76Z@(JAo@P%y`?w#MYNp(ywIb#p`KrhXWpia5Hqf|=Fe?cyUD78oQi710 zh3i5BdGi}qs!58-7=nB?x>Q_;HVYh!((WjeUl6B-_VWTrIbszugay9$LQL>p6VJVy zbad-)`A>`!N>24BqzbiunyEjdkS+ErVjtY^4@*Klhtb2XO(qKx;aLx6mp6#MJQfv9 zpcs674(C08cgBD@neO|?U2qL@P-Kf#n*|<%?MLq9OS_Hq*f0Bo(n~7DVv?|IB`t8G zKAJ5w+#wcz4aNj?>^^9pTGoJJYt5DVq-Knd-9))b^|r}@X(PkEjnog3@&>&l~p$P5%~A$*p2IOm|x z(~02b=kPlxM6SqP?J;Z(x|Y82;gi16G2^ZEm0`IputInR4^m8rq5cuE%09Wt{KPUb ze3K%bpXc%7Z8vVr^$YTUoi2AjA<~#z4!REc7JO8RUoo?7?>wJU@tA8*t~EdFpvK$V zdiP)H>rEkpBig)zPm@AY_u%&hsmca15h_D1K4nqIT=Ug&;W_m{cG5Pj;S;hijoT3N@J?VmVY!2Tmv#cjyfa`}X?ARKndA7((s*%b42uR;SHfC1q#3_! zX|f15{ir(0InV9mf%S+w`PIlZ;gpj^K?i!t6>svZ@G_%=XrR5IhAO`wlheY{`4ZvK z%TzeYS+_l0z{Y?Fg=W-ms~E;9Z?Sk~#6dj2cxpQ&)GWu zDVCRmP%--c+rY+P0mw~z;HN)?Qt%T3R!|rP9b~xj_0-eo*%Hpxq`eDLH~3#YT`Uq% zb$g3L?lD}k`GOJMS_590?I)s&>WP_0+JxS&#T;);)}O}fZ(bSr+`eS({ghdpdEY(~ zLVD`HLF(B+_HfHl1X$$^9C@o7&6LMHz4i01uu@FwV2QfBz8#)SGFY^V0Duu;5Zr~F zJz@_1pQWSz=RfTvG${OkHsL}{>y5n@{_VFJ+pOoZrpF%>G3%%btdxuKF4nSCU_0#W zLa;+XR`j5EUGfJ^kU?GjN_E=V+nV?(o%)TQZhlM6gMyKDGtJn~n*%iK)_y|98TbRy zXFs=vxVkZCe*nl)2fl_%)l_;xo=K`}+a~{5)SuJ*dWKhw+eOkgXRJ3}WeVqny9N#r z_>jULX>{k}{a)T|qCao8!}cz8Pru7i#7($ODg+^oj$RgdjgCUX(c8ZNa?WM4L}xD8<L{A%bGQ{@X;r=W zJHtu!2%Q_BXrQ0wqyu{dIam5Vx2F2 zkYcP9V9HRAE$p)*Gfq5z$L(xL#Ta?kF4SB>O$B(LQRn~TFh9UH+Ns6S!#MkgJ8PZp zwI|q<>f53gcI#i%tGy$02{Ir=Aq;~$5$QI6=pr{wy>TYruqZfik>0&Or_aAY%+1lJnv)zQM(5|Nq=hZMZ)5%r!}i3yNi|x7Ce_V zzRZFl4-iWbITxpG%>LZ7j^Ox4UDIfyw(Vi<6t&aJZ)kKFyJacK;&-*m=mnf7m;ey1 zK;$?cY^&u2UR!+F51Ix0~A?zPER=4T7J^76r?bJD`I10F3b6l;kR~w z0I_mq24vC6$V2N-w8fl)@F%=iaf!BLqx!)S4_Ftj(Zo5;r$zCt6WN;KfkrAe; z{m?Y#`U;tg9sDOfqkQ5^dJM4|35jf0*~!RlddoHztE1lCxdSLfem}Ju^|_V95~@-s zrMRz0>shMX<7~3W)QsE|{8%&_W!+E?*A2JMX>uQ(B~)m9Dn@HY)wRJ(ZL6<>50O zG#S=9pP!{OnOW}Z8(?d+txyLhG?jZ+aKQ*%5{e=55T{S=XE0Z@`xm*0F zi|y*S%Q%X#w1vtw!T5njX9q@8*rAPGE&P?xOs-$bhuvC=WJvWs6;;U9o-j`46?2(; zyDt;K1 z$%k|pS}MYT_1-bb&z-NIRQ{#bEy6YL)KPeB&~@+hpQ%V|qQSpg*u)@>VVVpg1)9EK z=!(vM47MNGiFgz$ZW2Yh#vqh2t)CydtfU~3^u;dx+)tpB0pWoYc zbyd2*;`?S|dQ%0QORt*p9^bDlBCA+u4h8og$Q%(Qz|+-;;Ukw~D?XVnf1HZy^DdtR z%l!N}qN!-=MQl{^qkTGVyH^4oxZn_N_yt-MAy~HKk!}(N(}}IFyrGME0jUMFxfz4s zPyLbo_licY{vN&&WJd~7)sJ8TCt1gQ)9=q%+B_^DP|OUu-br*nO8BkaV|!-~U)s|9 zos9eN0=liEwYAR*(ScSw*%l>Y)xA3Vfi7C$>D|0^dZydESd9_sGow?>{n6vKKnG1& zkmtC%jL~YAMk#yjt2H_NH`VH13dy$n62$qu6*JUpJ@)jPTD)*KXea2DfoR_nKlC|* zRP_BtE25%%#XzUqkvG|*GDGe`1hrJQa7k^(op!#9a%rHQmP98KVjLA~SU!vGJiI8g&_Sv0-u<0`+F z=Xah=<#bWX2>G}N6xifi_;+UQcN!K$>SN|IFk*vPigKHDJo(wVi{Gh~Web@GmeP&% zs(PzZ4P5#HsyZkyOhHDfnvlQla@<7HgKW{d4~xKrxTXlvg>MoYyw$fZTN^4i#i*Z1d4 z`WUtQ3}`<13V)Aye>6~gm&sySk|aBOb_~iTW;9aDPq`m1w(6c>2*y|~ct3XKKh5l;hf$;)e7-*Ur7Nc=LLT4&|!gTE0I-pdVH zOFh3--ML+ULK1W?3^GAp%>)v52VGV*6a1Qq^BddC;PhFN?i8Pwca_}ko=}xM?umW( zkpu`iXrK%^+UR|CCSb5#qq(J|ORzkyz>9IwB)3I^f+MBDt)X)BOxt}Fs?^wmpgW;M zBGQ1W<1gmAFIp|1SuSX=IY%Y=bcxhUcSb(WoF^uPoa{V$LShNc`52vBHxwyze>rt6JJn~# zcx}DWz{A3tWUq!3N0lU1R?aaW=s-3j$62t1*`9s#_dFU}>ADGl>?I$;vI+aad$lWg z?&HaCEVi)zH9PLd4*-jxw^t3G6vY3Tc;W#Ex2!^N{S?ZPw-Ne=38O1r?F(0er z-|bLp zNYZG6fDoON@&c@qX-8!0`0TZ9ETTeFb1qSmq%peL2LKd-aWaTZsXauJ<1gGVlySuc z(&+_L%>?QuUMNU8T0(jacS}b!Kfuic97S?44+=?|C@;Y5&sY9Cw#kPn$#c!x4dLqq z3Z0VI2K&v7Hs3BEPZjra{0MZ40ta0N=0Y&h<{q;v{qAjiG5y)JV-8a445h?6Esr|l*I z*y{=~Zw37dzK3Agq(RD8p(9~^=@aG23%HK*6Q5hPzGKbG%9$BZewNZX4j4oM252Bf zXzvc|Pf7%LHmN^k7yjTk<2bT*hn0%#$SR9?2NCfvrSGq*_*;Mu+;m8lQu<-gK9iWk z$Lj&5mtU4p$VcN?Lrs?^SSRUNr$ZJi zGjC*Ff=Lzd|N($Z! zjGnDN;}v0c7a!=L;u%T8Dueq*p23y26`U8Jf|452%>sfRF1#BR;={i$v3!nvN$yo> zZKEwzWJlrz6vNLS1BrCh-Tt!SlE+v_2R~kaM|?rY zt>zgv+zxbO6h$N8#%?n7$PLDQ@QO-PM*Z-A|3Y~$YEj+`W!eW9Rg4m>JOvy1L#9bo zdwEvg=gL_O(&aY>5TC=bK7g@HvF8eO!sRKIe}`W5@N=HsoZ+YuU46PrYg4mu)KvsB zAVA*nA_=rXHJCRbc5U*QeNy7%V)J5EGNU>!4G*EVW1&+I!jmy;XkG@{!0?@9eRilI)=%_$vevI6 zMP)&l$7rN7+nq#TA6x?q_s|3n#jeJ>1;x## z*k1dcD_6>GZ@ry3E+F!ibJ0H@fC{w2MwYqp7W23~ziyJPcJ)lZDq)QD=JU@u&uN#w zaPvX!%`mSUex%Y#E9R;oQp!wQSHt-1BO&*7qur(O4YMc;zzM~ zId`ULUzI@h4qA1!R-w-m_=S}{#XIKMzn6=z$)%PVc;*b9Id7)pG!^Ov`u%(8SfvPb zFgqLx!AuvgrM!YPo<8YWk3nWXLpT ze-*_X4({rzfjVcsbVP&=es2W7X_CsAn2%nG^2e8sI0kh442nLNngXO-2TlSO7BAUT zCy?IKSd6H@_mfwgusm_doM3VlN{*v5+?AP6I}r)qp^c@pC;9fSex+ba-;d&?WB$co ze|)H8bXpJIB_lQUydM2730B_d`^u>S<@S;J`bnx2Blclo9jZfU8+mJ5u5WF!S<7%eRZgPiy&^FifD4Q4&7fk{Ey${-68{JkfipkAdC zT#{RcRT4>QmSk@2AovWR15lwM!159@BMcRsVEo^8AN&hy{ZpvPRm#s@j2nDIsYP-a z9aWz%Rd)WZ!L_{-so(aLK=V~@=GuXL8(@fB!j~yrTwK2-dipqxLvql(7QJQ17go}@ zmi$C#L3~4!>A`!9AH(qZ@FQF{lefP#3%R+O?%KYiA@n{TZxYq}M%qku>r0t9h;QgC zj@frNM!w|*e>TX%qfX4B%e?E{U`Uhe5>)svnw0nW;|qn6I^V$rfVLqAA*u<)eun$L zXrReGacR@~7M;(jEAQ83yYhb+n@jmvbGd!d_;w-tKG4ZQ$9FWJH0)vAEGc4H@?Cys z-YhOfB=YBa;`T?#)x>$S;T;hK{@PyMzycXT%1xAPK9 z{q)<`TDi3@HY0b8Y#r3KJmk-!-){-*3xR@!uQxgrt&K_PTu-u4`@aU`1tI*2VJ=pcF*Bko05 z?{CdncBFcmzjOJ2OnwCxhmfMMFro%mU~2XL_kc|%uaw;meE0kkNyH_sJnWl2f}*-? zOFI^CkJJS*Ev(W(%m~7mkotf^BR`SG&p=nTH9*02am{`84X;Af#XW_Wan3BF6A4M5 z@6x821-C(FmM}kDADX>p3NdPsPl|c;U!ygFXGczMXRoG7Wwqr(f3dzWF1!85DYz+h}qwmL8_&@D*K{ToyWPr@(t%Z-_*@dOHDB_aeN59RIR}Vbl_J&QVJHJ z{ROf=&)Y1*gFK(y*_la6BJLQv>Brv7@qGE+mbL4YMC^`B5Wo>=#D#d*TD&phhI!UQ z9iPU+XX(=iC!^HLyB*32sdyf#EL?N5B)LKD@4!n2{piu#OUS~!as%S!a~vVjO#J)gQ49!F!xkiu=ZBXTZ#zYot|HQrHG^xKO#Ub1IPWtM zw+2X3K@z$ERoy(*ftRc7!6&T#)f1Y-)+b-@ef%LlEu~5%9#{QZm43rDSoCKQ{5~`V z>A*xHwH|MBjTON9k;f|?$eVL4^p}v)8weY?-_euIe!gEN;`6-&B!GALNM5sV_!!Jl}gJe;NcEwa=&kNA?5$yuT;-7jC7=Zm1gSAdWd>T4fYkes*UW`l>G<+UGw{_cXSR30j+kVo-xj|iQdfyyX8zy<$> zcu$uY(L&Pge=lge ze@Nw}vU%hm9D@56Y5Fw9f4a@W9x;tbK8GMSAEb#Oczy^Ok^_o?a`dcWgUY=Ejc~K1 zt1ry7Nbd=dW1BU9KULy3TX^9V#0mKJd&8qe(uxxq;c@WQ;5oyxQKyXVTz3se*W&qJ z@J8QpyWHkir(@df-j{nAoIZ9_#rmwQ9P{!4i11)N_JGkf)7AYWk>5y+i@n6%Vg@c+ zm4GZq_Kxh);ctTA{bRQo|=(OORn-_kf4e`=U0u|36=!WRi% zMMaOc_?MxpIs|wQ#t*ExkpG{~bx!~1h*7KdBiwKKb&WN+pHcct|LiSRd1^0uX*@{< zqQRzt9FHT0uZ#w&whnmX@@t9*w2yISEHgb=94cj{iv{9Yt%^LfU-16CK7z9YCL}lx zL=as)SdZ~~8r5HDZ_hlLF72mgmq;}7dEH|owmQSRlfiiSEH>ZJCm0nYKsD2f?vMxD z>|uV8Nk=O=s=RuePe-KVu@fN=?&n0D7{@V3+QmoykKjAdW^KZfxg69S)=pXoo_B6ovRL{~l^0qQxF?A{s zza1o=Bf!dV{)y>VBHh5KO0R?#@c8gUZ(xLX>kmzngf<%E_ajxwEqV+!5;J^m4J7n+ zb$K?^ZPz{MGuTW)>O&G1paPV>HA)4lluM;3GI%*FX5Gslh_hV8z#`7Zh z)h5C&N=Y?}$+Fo-f`60m-Mzn!zFERn78_d~9Pz(^P6m28AzsWF`(p(sa&ui(jSa#nC=8R1t=v%OZzV9`HDQ*KuSW6GZgf1JH@9O@Riz^ zu}BPvsVk#q|7^SpRJl4?3s?tg^AU_2ewYzpZ^CLBCdfB`NA!D1=MZ5;&ykqm+vy)A zhF7R*jpjbV{-8nIL0^zB$S@V)_xZ*r*~($;Jg=XON{Gw8&KN544!NIr{};FLjRJNK zXJ??3fzB@I=a-9UGvJdUqPumJN)d+Z52W#gPY9gfl+@6DH7HxJN&b!J`g@-JJP@c1 zL_ktSFJ^ztaqlQ!4ufBeNFQI@7TZ!+6ZGA*4c{|-AQdTJQ3ql_Zd|R(N$avu^?}6p4#suE{-$Rg2hKTJ zxhv>#Ed?~{dRSVljGrxuRTZ#Q&|iBvGz;1qVs6MitRLpblzn{mOzE;SVLZ|t)MIx*xhiH4Y=EWF&uni+9BhqpsPB4)9RyliH-F{O6#*gppzAalSZ9a1fXUFqz}@@ zFZ$fw_KaGl?Nx00>mDy#dknw+8j&&&yMDj7pCXLHg1kdCEGm!2ux*#0foI{7O7*{0 zk>0h@iy>>bBzXEbWBv~Q2}+$F*#gfP=)(hWpS^*`F>ovj3*AADC4=LlmXYeS_@2F{ zN)|+~qRi7dA9(tEh>U*U*T66p9lgx{Pnc_cRxqD}&!7D~uPnj1P@aaOErId4_Af>( zBBfZD$|?665W^y1Vxj2<_b_5{{^!Lv9bP(bbFHaY3_T@SS8xAYcx~vUTQ=wu6sAS_ zkOGHaj;g<%?m+n}-;%?bRLB~mDWtKTV4@XGe2i@-_#;U_;1|(CBi;K6$Uo)hLt;*@ zhm)1{-n^+;94WhO$^6-u_wMB@I=>a-t{*p7e`&Hei@$mqu(NGbP`4KBiJ@DKy|~ux94+2{ zp_s9${s7{b}6ktxH!+bS0nSugf(_bk<4p8GTzmzWxo zHZ}5QV~*h2*(jh>fHXI>)@|>^z}A~dy$&P43-5Zyq|i>24yE>lC@FV+EF8m%;|P%u zm)1nVUFda>`d&TKQ68k!w``5ezEr-aEUB0ieN66K%x#=Ap?ICBo$+q%)_6w=Gy)YC z1JeL)YkinQuM^lyO^|Aaj2>V5b!~L_CJs3p%MIQy{&~u)&%1kWZg+10z!R2(iRkEa z={lV0TSnTg^vhiStp*DXyA09G?9}_u8x*>q(CWv~8NbELF4Sss`xkLtFVupcH zrSo$>_t%)%E`=%4E<5o!B*=x;H>e*AIm(?_Car|h76%hr`ahxX57tTW179=#lK-%P z&a+ont!@x2bw|)PjLd)69K263YxNq;01=3~A@|;fj6j2P@lkVS>`CPksm|*1(=WP) z%h)O*X1A6icFx2EyF;Y$AJBo(goNtT(lF2N3`-kniT+z6%Hq!#Ov+d~u(~DA+MITj zTfiY+_|?k30w(-^*EjV3z9F6z_+EjfC$C3o#O0G0NROzk<6pa3b!z2ZS#7+}CGC^* zIyd-%4hp}Jn0w)&G%|mWG<-STPQ~vsS40;9XaSfl|}61X7anT=4)Ey)FE$ zc)Wz; z7m?$4LzFeJ7f0CYZH<|xmr)l6yOIR3g0eZSO-!y>9NXG!%+d=JE7&*XA&D7%-F~AO zsXi&HnO)KmhGV7iOHoTB*J0pz;=ES(4_?b^QQd_TQ+i-!3Wz{`GU~aOBkT-pA}d1j zax0ms>yLZVD(hlVIbK0%T!~eVLlq@XkiaAkhzA8;m{)+7&K*XawUJmP1qC8o=6=sZ0ctxM`vo;Ey@ z>6p(!^Fjj)Tfdo9S<^xunsdQ(MN8WiT0xmyYiMI0^lN-)Y-$LNTVC99yZ&n5?u9v% zXbkhC9SN_oLUecqU3Gpfd`tSH1h<%6 zNuX|F1FNrl{LU3op`kPqZ6Rl>jPn-`z=)ccoP3U)#F>Yu?qORJKHb~+2^orVk zvpaCKAkQ&!85w~LYyF=;0H{zP3hgbqzU*J7kCpb8LV8}2L9iu>nJ(R&{GFZdFmLno zUtL$x2MB!Z|5HM2@57h6)a7{A92Ln#)kXv3SGOBIz0~VgOuzTW?0X);MT%CBt%rP^ zj&tqv1IC}+{3y*%&?cXq}hW{V81#>Df{)JRWH))-l6Lk+?39Se|R>DtF3y6@k zIt4tl-*_K=XBBy5=vD>jQi)~X!_R&hEr<8 zYjkVFrBVkAKXEbEJ&CALyjZk&WB%m>&0?`O3FklGj;ryXwz^NY^LStPK%oNqwI&}H z&NS*gH)0m%L2|_Y=6EHN;){T9!H=1A=B)) zRr~KhsB`Z)v2QrsxcG22$mq2Xu^n@roM`1$IW2c=k@c)Zzw7^g=Ud@DJ$S1m`i$31 zYg1n22R$Mx7_O)!`~H`U?`Zbpo}F`^61sB2`wkAMcR>p`zgdhb``dJb=;W+%ZXtnh z?a11%ODt@8`nVzTCdXMipjip8Je9{f?ZGjXtj%+XP7$7OtqQBs9%CP7t8jdP z&EP+L`KJWk1H21DXzq`GRAEUml(oT4p;XVuayY*?SRcuAZ}EJlE}`QhZugsK1I9x)QY=t)Y82-Qsc& zpzeNkHkz$tCol-!p30EGt*_9g@eb2MchaWqV@H)QaiS^Dx->@Do(0gKgcNC6st-wM zSqJOOq$v7mK_Dm(X^<$c`P_k4wIJHE_~iW~pN@QY>Az6q z9zJHf!R11(s>+sS6a81TVUY$zvY-NFv7((;UNS1Ph|tnn;d9Vw07(|~ zI&^=nQQ2}{y+ZW+%KCWHs$lW=MZtF;WvMTf8Xw7_I%@S0f&xPOBU{nOxeQ#g?s;x^ARgkLj}f^I zd-S71yN+S?Q!j6;3JMytTwnX}Bi{50${u7Lz4rJ&im`{vdqCpfCn~f9Z$Q6iNAJ zPP>}&Y|t$~`q_}Bd#&>Ij!n+(@dxn&Uv^?g9bW<+%#uQ+(d41~%#gN4*XrxjWkw%; zsq*)hp(#_?P7m0$NOq&l%e6PD;XK7;AwdWIYDY>j>pXhdo=R2;$4T+XctF&N3yhnI zxztgwmBQS2`ELj-twC^23_{sRGllNM9P7m6(+n+<6JN{(us|%(kmMH=fB-7S3 z>7Rbke7^^4d~*usGJ@JYpG95I(KyMC?cVur!C>X}-N*QgR09V8|+x>h1}K z4dOPn%8qeqZ@9sT^(RhYLF?%U?YFmC`?Rr}IOW%$A4c~#jwFd<{fZ!26>EaiFs@+%0ll<%1PvXjCPYN*N zo%$<8mc#Egc+HsCXCEbi7(;83#Bhw*?9pwabh(oK;|Nc=;P)8yZ=4IO$H*op8&(I{ zGt!;)*d;9iqrKk?{#1P<^s zgs{bs_w&~mb8oHmxV*j!yn2HTl=j``0@ZRU7sE|R+r}KbivMI6DW3$o{kGz0lfeT) zLGXU6!%}4}1%D6+^bJ>ZvJ-fb-;TU=fnACC1YU9)_uFwhK%meiAIS*HK;93~(TCjg zPVbYHYET-Bzc}&f_flz$e`lSefWPqIomrd(W}pM?f>=`XhooY5N34FFARXW z0>p@ruGVdl7_FE2^k#&{u^V6S;643;|9R%7q_NXie@#6Plan1K@9)}yAq>hA99JlD zl=K#(^<3uTD+rl7@?E?JqHZT9oKXld&>~%PXZOo1%_za|1oniP38F}bMM4nb4JN~J zreuaSr`_Vo~%KuFsH> zU{HtX=N~bQVZSDk3h}~`Q7K<{bI-*V3O~k>%lC$!-zTUqEUWMBFpmd1A;|wli_@Gv zjQYKIU&QJ!LsY2ZmUg=A4ZLf9J=moma$VU@+QT%L0=9mzJ)n~V;&)s6i8*JtCs$up zzGgUuk-A@hosYQ)V`GA248VKpJJIUs_K zI;zfSt{ZPlUNZI6nLm&)1(|c`W9fo?N2EZB-g7cV;`sOURsVkN^+$t&7xGn`Z7%H& zzn0EuK4OAD513GZs&WY}r2riq$qpch&i}%4OSWN?=x*PUf|oefDUtIfcQYEkG8rU+ z_ZSLC4uUM%hi;{_AK7$hKmS?pV+c3yJKz8QM20S9Y25Lkd8j_R%8Ydcv^6ipg3#-W zLsBr{HH!CLC~Q}jBavWBxVQAhfAIsg$Gwoyf2X=#yvO;isqO$B6kZ`VP|~4$mUi1& z&9m_Ct#TqY;w27M`uEwmJzDW4nb)_-Jn-oP;S~!*YzE1TZ9fdoXsdW^s9SaEe7N+1 z5t}Ml`hM%oQ>vp~q2F}FkKuGsH3J<4t&mcX^v@VA_|e|AsLnyl_%9i`9nMW5Q&C@) zU;N)cBxbp3u2jD#gdhbB{DinD>e}|IG0#|gEZu3S*P*a**($M$ty9FucyhbZ)jH#k zn$QtS(Y9-V4xm^XF_qk)3KY3FCkn+NWmkhw*9WXTOR9>6-WCdWBr}yO-@kQJ?Drq8 zchGNBo~mL19qfg3#Ffta^YZjJ_FH>2uiPWzzLI_8mmoK*G0n}_q`x&50JerGWU(XK z{mUvws^Pn+&8}WnZKl?_@bUDEhix~Ga?p`09*g@Z*f8>_cS;S_O#$f-_|F}qB+hSL z9@IB(3jAq0F5j|XE^&w2COzZgp91EZ&5GH|?sE8?umH3TKpjV6IOerY{q8K)eR71F zP#~W2d&+e80v+kv{U4e|8QzTZ2G1TrEDpLy@gg0){A4))7-ym9BQu-Gt95e;7I8pE`A#9TR19SXK&9`a1WvT|~u#fH>^?&|*YvgHq zUEbAYl6NL58ngo-MMc3cgFKtzRSaEuxIuV!&n=Zs=Fu&eb{rdg%ZrbeB<7bs#}hr@ z;l2q{2YL&|kan#!nuY8=gVHA-F!mReXg0zI-`cz^V`=X2N8MzNuc@=Z+g!><{VFs zM$g~6qo=C#S#4dn_Tr*wy037;Z-x|R<(C(14B6U&4n_kYT@Jq=HnQu=U%sS9%ChJ$ z*e((Ls`1XCqPXFa$Nv7yx?{8t8m2%=i^=dG%&KTz#7I}O1!)RCZi+zH$_zZcVaer5 z_3A&Bbi}%sruD90z5N;7OEM5_Lp&|LNInbP+f|QzHvU`TPRX-c-;SJ+x<=nVR8l3V zpPKvOwTpUNxIWN92n%^OLz|fVyISW-y6CxH;T_AKjF7rI2^x)4?;|!0;<}z@9vciA z`UT!&Fip|Yr1x;R-?Ciixp482w8)}nJFf^E&g8aB-BGQ*I|>`}@oWmNV9~-DQwS!a z*mCl)ctn-${dMY2to)K3?AJ86o2xb7S~e{xC5`Rkh9@~VaPNnR1>hdg82-Zw#w{lh3*VWSrvib@jX z&=C(0eSUw32*75R5CzPVsztWrruti=8EAJ4UG=FjRTr~Yl?KSO!L#;=Vd&X1~E7m}tF!A?X1*{jG< zaQNP-k)DazNsA`8aW8dTLK&rO+0;4n;iK)(o@gd)oY03_4n?RMc-BSl3RLymSV+p^JHy z@37x@OA20g`SaYac=Ju_vu6g+upT@-^XX-N2Hy1tqhMn3!rMYj`BG=hLAMh65Ks4* z)9O*lGfHm@Ee6D}i3?yysHM$QpDIrL3l{__+fb#0Vu*wg4Cc9>eZGu`b;wYU!Zb`P zdaT#Pn$YCf=Yhvci3IDv=cF`%P9ER^8oPWtj8SfLvHw){To2F>{8g7{@jY*ijgC3M z^6Kj4TaoFL+<2;hc?5vl(U5xxdbuJ>u-71L@aiZ;SxoQ8i4{AMm+WZgTgqvcSpdD<8ufvvxgy=5FRpdRj_{u0`It+1Shh4kpMX zLO+krLkmRDe#iQxCZBbSm{J<=JFYJLRyAomKfF^_p90LV!nSb$^FW0g;z#UX#PE;J zJ0%1D;#!8X^{8pwy60Yd=`SKS>r7*7b53O5{TC$wbaJpU^l@}wzAW4Cg#(0m&@4kVAP->Rn%|He5gI$qV%$Ei-PE5ZHu)uxgR?o-JfS1&@-9x zQB}|tj+OvuB@acR=u`i2Xt?L<2}XR2jZDb5+kVVub@vnD+Md2r^k)OJyRQUolx`*i z)B!1jbU^sxh2ciMsS|oq0pcdj@&*jYH6HWVg=}8!bG1JG+U()!hu#bjQHF$YXefi? zs!-?#hTQU9GEJ_M>D2RE$C=6VIY@VG&+71!}xnEg)8R`U2mZ4223gsU1eIz2nIY^56RRSQ+8>6{!3Z=?{LN;_PqB+kI)ck8Aw5 zyvJkjW!3#~yOCvDYP!H2RR5|AvYkbFsj5FPAN>BMU!jc4!>cT_f;Z}@y80c%`ix## z>jqcS-t1!oYmOQ2Fui?-hS11;k#Cny+UXR1@90pEPq+ z&ShU0Lx&;sYijevU?>kpH=^$zNmJ7-d17B?sEe}v#7Z#X;5A_+<}Py{@f@8 z(|DI+&MPry4~rU)HI~E}pFzJmwP%LLK(%aYaPx!0R@e0`-+!pt-sPc~DSGjbShpgV zj?>eyzRjRsSlP~5UUQ?Aatr@3n-e&sr3!g~Q0#utlr*CabDxvFA~WN@c0-KOKlU~m zeFit%X_JSpC72DfUG5ZHXEOt(2-B#MZi)p}81X17qx+J6oekXfh zY@X+Rzu))y$G!AkYu0t{GiHvNIcA1h+68U6P23*$*JEH5fpURZ)jL^;{n)^3vsM?J z7a26)5p_@K+^T-zS>&`x)E>v08X*|w`UA*;A&n5G`3#lF0gSOS*%4^u{mb%;#5Gdf zTVq`e_lUQ}9-(HYtG-3bE)h5nbb!HD5ElJ%87TD74!&2DFq?v0L!m2v+>lIoT3|Vm zz$4+$@-zAxvjX6~Nl0>E1gO@#5UnDJ^+V(tGGbe|U!p&2+4moia80tn${EeCt9{cz zpYwYiSW`iMDDyixkN9~~KOg%&-3uXQ>hRO?d~2lmlpJ;VgU4bNdw~Q?Oc&Jzu!=ka zV5lkVc?@61Yeh<#S6T`FU^47fRjya2zK=oI@DJa-CU~zyhLLHlrUA%-O9B;|x`XgH z6tB>&IuObYVE1+vn7FbwFZSZgq4f=PofN>K8Q`g{HV`m9sAfq86E2ALYMM6Q6 zLBat4kVK(Iq9!DC134dbYS4ZMX58SDd{uT`Oo}=JQ>3n_|6|{L(>}vAfqcK2B0Re1 ziAlGgAi~(ZG&o_6KF0fD9iIQWo&EVo<=cyG8dA8Xe`MpTA9t-6I>AQV!j zqOEcEUQ*1bRmr|;Y$nWlXZCwR{YUm+z#0HvFGQ&M9)fr-vJ`Q$mR9W!nBCK;cPM{f z%_7D26B8*5p$i*8^1Z#21k|krKp}7pSyoDbc>^$}&xd~h$3Q69a^Xo!l|4Bck28xb zk4&q%q%M_sp}(y20aaT%!jq)dcGLvK7xATO8ooOUBZ=I7^HlYIXFtP~=M+YaCzJ8& z=~KyFXAgh_4RjB1p<(yq%pZO~z-x;TpF<)UDkN8L7zPgByB z&H-9pT#^$s)`7__&Hq=@5-eHteBGCSU<-$nzEvm>e#=fdYQ0*)c_W{((bRFp+sQ$L zyipTPkQoV$kmq9IVIFBbayP2E$}4CCmSyxq+lQRW2YjxwF0>eZl(42C1Pd2CAMF8K zK*8mF_vJaJeXWGLkJWMKZIY`{#8w^|f|JdsySTIh-+_y(SYMRej zPlY+zI=LgVQA_r!*=uRdjMQtPO8A=>t9IT_tscm0+ffe1QP|_uFdfpqZC1a0!+F4i z!-6W=8u&LHAmj;Ae1mHdm!yV;m^S!}N5HC~(8mF-&^DXZ*3?$bq`J&Bt`H`a1(3ny z0Lc`{Bp!T6C?DZ9bpdmuA1jNe*KkjB4!ph0&C7&^9yRV$WVa3NhR*;wPyhsx*-kEl zmyEa23WufnwkBmzN0|At7MLZLjD5%zjO0@rkQQ?1!J7xF0`!)H-HD7{gd06PEiU~N zX|ALBCl%QfKbo`Wla4crKTjA3{xrsWd|(3r8iYJSZ$_BhsvDwSt5`bC1A}9qf{bnl zE!~WtoQ(jT*5S3W`dcd9K!!8FGZ2ge-Jamlk2yfLfK+m1wFtIongrufYT2%kyRMGq zD`ugU!}1dEAidr%9<{fD7}ylZ56edE3gZfcAFq<83wLSX;4Dke;n>SOAJyG>(_~5m znjrC!LZAsjFapAv8T|;D|6n-uJs!)>t^yhI#KGF#l=}6rr)SUBv=8N_`ZtKLftpip zeo!3-*PylE5y6%UCkkJi^?Yp>rdF5z+af7Zp7m4c_ zKs|+G-9k$2c_ItfKQ4u>w|3~q+unE~-*oJ2kfAK{t_<_z_&MVpL~fy?X0JfRH7mT9 zyyO3!IAbTnnnnXz0{A9YQm!Mahr4Cy(#~jFkmS<2Z?B6s(E{|96B>a<=le&yb zRpD?^yJs3!9lJ(L*$s>Qo87Yu!azbIAh}<-dUEp)3pbHJ1;+!QCZqTe9l){#)sbitYZ=@jDW;OkRHtS%HdEj4pj>M z`-`^z*biuUFrM-P7(=b|fT}f6XpS^_Gm^!C>{s*Spq{V!#gt8j2igyfEyFluB{Gm1 z;p65833}K$ltURpa1M1NoCX+4VgudfJhXXFP5O^I47y%_Rl~P6l?p8)CbR%@JfPh^ z{GJVix)><)({d114Mr?;i$5V5{><7YF4BT@w^NRI-K)Iyq}!7LxM_f&$pOU>*yOa@R|AiJ6p}qXQ4#eddN}}!B{?{uNO&6P9}0;jCD64T zb7yYXc8z>xq^j=G*Uodj?lzS?3%k>*G3;&4Ffj_eE|72KgmxwAl6cG+^P_2eNaV|$<;~MI|EB^!JQc0S zng>N*{q-L7MtLg<QhR8P1_`v18 zptT=DAxm(2Dea&0rnJ;XvAtNoqr9|Zb?)MR;Jx?&`T2r~~+YS6Nc01L^yTgp)^`BaI)@=D9xe zZ(S4@-+%wilT(x%&@zD2%mcXxv1bTfZ96G5%kl84`$?7CLRo0T2h!h5N`E=oNXqz% zre#%F0U;aE2tZf~_8Kx<5Zco#RX9!+^WLEi!M0g)OjmG0WO=G$lI|32a`3%C8=LsX{vV@#xmLKx-Bl$1EX1dUlM+ zoM4Cb#57TxCdGW-dSd$gQDa!w(=P>Y83ogS`zo94#iM{|8KAX8u|WScgti@ENDQ>z z!T*Kz#$3PRdE1sj*YBIR)x6>>%*&krkhOslb4eb44k-WGRDlRJ`#KUW8C^kkjLZ=; zkDiLmOV@89YbfMmkg(cw(5&hd15L1aNh4Pg;ee;IoiF!!#viSQ2U(M{F^1a=?+|2C zj8IL=lPz?9Z3h_)NpPzmzCq-rl4amVSMLt~8Aq?otH-=&x}dUWbvo>B8ak>Jqxp^^ z4DbyApZ%gN#d8?3?-DH>Bip_AQz*F!oN%;$l*avBa<)0}A>WfLQhg=G^#?c-z!X3s zDbMrvbMxsWq6LWLNM@Dz6`%lNkOtYuDYg9o!^=~4|b)Mbp%vMNZogzxk zei-IUYkpc6){Lm+uz!Gxi9_zC;BO3;6f9~DSJU*ALg(=>Os!}0MCV{c3=mh~W;eVE z;qagtkfuJ$IriDwu8pu9S#cKLmOB|mXF&GOpgvyUJOTg}jQ#|HA=m{^12dywgM9u2 z-#Lp6pY+S!HLN6AKcf926* z35f)GC5|nRERSqd-uDHJw02J>6dAfdp#p0NVu28Kwc>JW!p;G`$pWSjg+*n`HmjJN ziS!TaH53v zCw&0|Hw8c6PktuWdM7bOd)s|@rXhIFrXl3T#p0P6ayxGvsJ;x?__@WS z>Z`L?s(IHP{m}t75|;v60lsPbp$P44U|`5LNkgScOob&DBrUgJ6u9!LSjPU>ZmJj!3cPR>0kFr);& z^xX*f(t!fSGn2$~I_&XKd7__KwX7(tlq}s65}ccr&}(-u)WWkIJV+3hfl`>Ao4Ehc zPmKEiw)#?7BNWxZ9TdKivicQzLZe&zF_oKW=*Wpbk~#>dhoc~0vn}cUhOuJ zlN7w@Gk*XERzlIt=NJiuv2}5Sv-v8#`Jro+c}d16%&r-ZF zp45*4Ind=7+V)S;h~v^}Vf*ZDrgRj5lYdomz+0V1hv_9x%)ft&HY#M~(fW))4!mY) z5bs_FqMr;3g@K;coJ4hCgh9Ge9MTW%{iev(%rZ|r#i}$nIWxd7E3S$Pm#;Kl@4JYg%h27M?qND#%8N1?b?Q zG#-uy`=$~4^mXR?=j#g-boa;Ax($sK@MUYOckJ@N)81&cA@1I^eRg!Pn^$DIUh)-!JcQ>r4sb*8=^=@ z5fVPxlakexCvJ0nCY(%M>-k9t^($&aiFD;TApnpy;RjdiftcO$yy{4eNj^D<1N$&~ zap>;NKbZk9;~qAlkz4w#F3z$R5n=&y3m91p-Lk|S|_-fB)-@uR8|5X<_Jx)rytrpC~(*nRW|6RVxSc(e4ShQh~I}& zKz3k-8turV?(%?r_Xvsghnr>uepXH3vj`;8WftHDNP=;P5D{mr1tIsf;mrd=(x(Gy ztvR!-$K+RM8Yrf<3Z-0#m=~zu$*@ENE5-#1R^SJ?Qi!-{t@P^VGNK3l^|eL*3~zH8 z?hCyykyH$<_=bloHx|ZB0OY_B9Vk{X-UU}=U|-BKKA0M$B|J(cA=!Ss{NS^mCUSk4 z8~ST3q@8@)tr9~355c>G_OmS&Y9dNajdotD0RDqQ1S*`}>d*{SjYN@<#HrDdl->Rl zZK(}Ly*q2ESzt1*4NMQe=i={&)!(&SWVX0%*foL`lzwLVPr+*br|2mZ=G z#^S@nnDE74!bAAdVMuEShE>$uw$57DJ}b-|eKnP3cG`LJ*6^0PpvlX3-Kn2Z9x?1( z?73E3I(xU@ij1ER^WgKFA6{@WkcX66`|&-iAu)X19Qy<8IR|jf;CDL+4EKftBK$0i z`2U(u2>JdbHB&v#RDb`aJH@5T+9FJ^!5y0=pA}#L(0dK4SV)D&0D`w9PZ^K*^v~_X{H;UX@ zwR7a;JQT_X0Xr}c4vNW-L&_Jt2^G#CGdxZGce{G7iw32Sc`lD1eNH55-Qdx1+|aN? z1B45ZmcMvQ8Tp9ge9Pbe-R?^WYnRKvs1x7cRM_2Y<5N@`H*UxB=k;0u!qf2wg#Ox3PhDBkxlX z+OojQ21mRX9OnPDU(4t&bNQA3_Rix!k1KM6uCTD{+EI-FJ-0(LR)z&Px+(A|xQCZF zej6m|PX*l;Pu+1Yi=tL0LLzb`M!;jyCGFr?V8Gm&Utg$G2SHZW`sI z4QiUTi=}C{hu>b20U3G@(u`O*COidEt=N2CIeEd%1=Lb=9v*ufI#E@C?#;83z45_7Fk^wg?0U z1tA_r5%jyjdG|-5Foud)6zcob$%`uT^4QlLvopSy(JWwTLYmIMaSc3Q;O9Xhn;|gk z0s38EUocbDtjHH7ad6(eT~vs(H}koJeiAvyzJB6bp7YmFu#EdGm?H*ZZuy+U2s!T< z3vY3yYTWpx?~eLzH{3%z33XVL zLrV1Fqx#YTjz1^!hI+;r2z{Ni{2*e@HXutvkwji|7Tgjlf%%kTY?sL;<6hjOdxA|o z`h!nirEKg=`!s;|X@Ic~k0i#$Bd!(Az$uaDE?cbD2U?dlmlLsT%AMb-u@{Ji?H*V2 zSepYE26QaFh#0h9w%eW}a>|i+d{Q%l;@Y6{SNg#0j>>(99WJ$m?bDO9#a|*o4ul{t z_#!C?brKtLl3kteul1Lf;x{47u6S6ZaQOYnnUE#CigFe{9pL&1ih+haaMeHa7rst# zY?*<))`1?aW_k-djk|+o3G#6dn3WS~kW5rE-^rpRpI0`3i4@Q^Ndnsmg{ukp+yg#! z2$oBoHZ3h+Ic&FeP0IIQ;W>F`U&rfUtfK>RNBp3L7VP%VrXY6HUK@j{X91%*;>xon zE&rywZ~2r}Z`a`JUoEFQB$e4D0%GD^kY^n539(8&-0d(NM-mr_+`s$jnBAH;g6=JZ z3o+WEkA8CzZdrH*00hWyLxW!Yf)L6iU2JWick~pWJ4l80Yqj=5o_NQ*aQdT3T(~VoI?>r91%?o*6k(b;;dH?>p)h!=`uCL+ z<2w4=ow2a?^|5G`(T8H$5AK{`Ot=BpibE2RvEa8odK7UVp3@OaPWdYI1rq0bTd=z) z{tD2{ir0HF9-fekdpJEG@3j!TdxazV^=WP9w9wUibUkm0@FZ)HU|NkexGC zprVesW&HnYAO?EmAwU=uu!9GV)D>txdvo-Z+7G`d5^uh`^n*ow@6#EDZ{r@SEUj(q z+{LPq30JOq5WX$oT5APSx?0()-X<~tPkv$IOOZ5d5{T}%ak zVP1`v+tKW-t;R};Bb*U*00w#j{-X;@ApCwl`RV`i2e$k`7?xE3;rXTZi+gB$69%5o zHJkwqt&;04pX!8;dapOOUfG?zSpJK)yTfiZj|6YXrA!?0-XGbu=(oCF&yxQd3*%>} zloWVgAgav;^Wn&%49N$%RLje=fc7XC+H(4_)%sFO{3F;<|DG+kt6v z(4lo*_TRTXA`k1Qw7yy*Kia?erBuQ}_2HRTH7!QTG)@)Y{ycDyxwyb|Q@EehdD++A zCO=Tx;dW=z(ku@~fT!ZS?~JXecfL*G7}A)cy*dFSR6sv`&@BtTUw?h!&ladFQ_@sR z>dfkrs0^}KC*Mn1=szin9W6MmrzmanyAa<43~@m4)7AxFOWH1Z2nF78EQ(LV?xl78*YRXFU!W}ZnC1KYr8T zeCquxS3I%eBj_)}%MS`NU|PJP91$l{J~>&Pn6Bd)o6ykw6?OH1-2o%RUlZN zt1!9FWrW==(6XjUu+2S=g5tn`3^PXaRqjm?d8r>xWH?J`2BOg5ys{n zstYH1yadhp za%jECa#&1M?%HybS)t;D2Q|9M+BWmc0|dnZxOedA#?&61$PONt41HOfHTCYIpSAFf z#JKK4(*D;b3`4|z=XTmSO5bM8DD zl#@|Y{9VN%&V`261t1ORQ3X-GlP;qvVHub~+vV(A!HQ*QSj@9)RKtqsc9o6J=1FVy zgC8FPqbLaS?@%%}HWINf2i=ZG0t%Ejo$$qNWu5(MuyH*3<{q}+JAE3G{ALUd#Loa{ z5)`_?&LQKnUPXzkvE>9!W9$#T50&X%`O=+#8&=!I`fjs=FEbp39gBe+m?RHHt35*y z=SL$Qopx8p=i6=7SR(HE7(TiX$;!Lv%{u{x{lCznZ5n~12dWmDezBd1C=BQ{R-@d$ zF{;6m@mm*t*_Yh)390d=u-R}o{-^SAfa)7c2r6o?i5k_B2MSN29^Xud)syg&8 z=Lc0u$L6XZ2~>zie!L?+kkNDpAPOi6C`>zAjL4;zx?=3?+`^v?KY8-!hwEzyrUYlktepl_r$Y#C`W@xawotgwc%U*B!jyPhvz&b$cg@ z5%=^2AW{h_egP<`{<8y-i&fzAQ87vqJ1dl_;ru{O>q48*?1l1_lKA`cH)G$7TwQ<# z;s#|T@Yh#!$-!#f8~q`U{pZcWtt-(qf%p$~9Rg79a&8`+HsRlRx6-`@aMhhVDlku>DIDgrxT|J1`3}q60dkUns|JrdJ5&$<`p&lsp| zoi_*tY$>j}pM;t$Z&XxXv$^M2`vBM|Fu@bzA@z15o&#I2*_DHrFImiSp4iZ1mx|bR za(L*F)=gx4O(&vJuY$0vG$&}*4*y;(2=+k^7Q4>(VfiM3!UsBbuR3vcJUmaI|7@p7 zQWSo|pcSG^*Gq^Z%|{xvj>t9BW-5eOM8wg?e3s<+mTqCMyMF3|Pd(PDEMvvW^yvu; z_>LHe!@$4u;U`pqfF_QDL>(;(>NJr>eLocF1ih;u*DJIh@jlSq&Yp+ZTGjgMwcp+OuuMzdrOISwyi>jXIftCT zcwGP-3}`P4S;LbuY?ft!Rw~PzdJ;SeuQU-w;cG`Qf5^?YF|aNI=>y<7qdJ%=l&1vPe9ej z|M&x2emM+aKUR5R-SzNv4rSyyKjY&Lp18^l@n`qY2_I?8!G)rT3ubfSh?OtS>lTDJlWpWYpxQC2@H?Xy{P`WsoawM z?RKx;c@%7*7(d`9!_~*hC8eN=U2#H0Z2!rZBB$qk_1eE$yL6)8mT+B96iXpal)u^l zv?C{|)Q4N|?rKDnCAa^v*|2}Y)(!9K{QsPL4q=?M)hkb|&MX3-t%{DyqfT%-3M#qL zS%%^XD1A04@s0xD=K%W#(FI2?i%v0(*+warB6NE{xp!U-n~C}w|D0Wb_*EGHeaXJZ zf|vk3NK1gRIB=`gUI=lj|95Mp|N0s5?pE-b;ZG{Mu-2598cO0*TbP`c@)(=fZ2UgY z9Czx8*}1jQB03f2gd!*a7E!!uh?8jYcvmRq z-kul`?<7D-{p~f|M54x(uL)uKE!F@|NdSf#{K7Rw;UYNJ|KUBrmb(V?6*PWDFrk;G z@rF>vxco3=8`jCM?dKl!!YCrn5dPQE&32*I*_s6PCSS^*#A!KZkmjP43Wgs}XZbI) zHd}Js^>t2)0F8!tNFyuZBw?^jhf#mjmvi17HmMGac$0-gly*1SUGa+_zgE@Sxxdi? zmI+4ef+i%eeI5WzIw;@a@OKKLqU}ag>DM&l$b+(AO|S> z5HYbn6s`$?0z?&zGx!!BWk);4n?6yW$vGtV{;hiFW7&c_5+ZFoGJyIx#Ls)rz`oZE zQL2EPx+_uTXlK$j0`bQ;4A%}Lc}QrK7!0P$U-|CYG2H6~=mylxb3)fB%@g5U7*CMM zYK&;)9GfK8JyYAY3smTIKs z>~m*6$>r}il|#!>(VDN-YwVCMI`^G`;|jljJIM&S(j8vhVOsAS8~C15d0cgJI2vwW zxmZy`-~Re|T3(QWc^>}-`AoRJ@LNZ~hB2!Z*1X1f2h%{U&+6Ld)0H`ZcI{lTEhHMU zH7W5Aa*-z$Jzp9(#$OawRF%91*YiBJ19yr4 z6(C3e4}y@fvg8==*ZnyqpbEVIJGCj2aH=sy=SWN;nLV5?6J&)2NJHlkaaj!?qYSyh zFj-}{ub%1!z`0) z?ivxjTA?fIkP!|b0SHKev=7{i+5Lua(q7a`9#2WN>3LfTjwH5F60NV%CbGFf6{*mphuK+EM+*y-(lJ`e*~3VyjZFUPzq zaF(8KYpnK(canbg2rHSoL(@6@@E|>`#5?X6y4hQh91@fO1LEO_U3}SgxySEKQPF0q zpx29_VBR?#-pS8=ZSujvM7~S$&gh)&;L(9LHG+^UnSJT{VDEdEee<88?eCMlMg6*^ zt@6%lSh>wS4L<&7!>(KwpLLOZXN7I|mUDL{vwZ8+Zpx){!uKHI^z?mS3+#GuAQOzdPgD5(MA{NVY*P z=n2G<2Fh>3#(`#vzwH3eZo?s!`d_i_z|6tN=DeHczK#S*5(zC#m|!1q{vQYKuI zh}51_X<_}9e)E-DN#p)!KYpTQ?cwJ$1=Sz{Edhvz(53bT1C$|U8`^un%kYiqY`&3? z!Tm==#@gy7xN8TbyT)x=G@JJ%uLI~R4ooOqsnmno1_RC0|>xntrtbWT$Ro7;k6n{IC=bC^*r#P~yPm#&Hd zumN~JP=IO+B4&a8_&C1f^{@Pn+NWE|w&G-rF34^9pQwK8qc0lqkfu|h0Z=9l!p4x2 z&7VQ+e@F0!3E$GRt+lb>L-rloiX`FF*1u}pmh8r~Uo71}0LG3qNCrYmFQy0bMKDE? zB+-#(kkOH(kO;6vk*Go0m^&QQqacZ4D8sBR+!xVcYobea=Nj4#3tcW!D|oQAqfA_9 zW6@{jb1i}%pGN!w9C$qJ=iw>1hvZPdXJSW}Y|YNr+JDp+RAa4eu~CVR444lf>2v|- zV=t%96g)9wtLsfK%$wM3UfuU>;NGX=zh+BLJmM3Fa&`C%a05VBIu2+m%jp@^0`t-r zxrD<1g>1a=&ubzyWSOL{Qw%aau`IZXirIByBw)q0gmx?iP(u=`mxnBpwX!uM2Zmvwqh*^K`q* zTxhplR6tHg6J-#toDJlFHi6j6-!F4fXClUZjHn{ZX93GbLdNXb@43zH{F|#6d4-iI=;HCEtH?g2^)Hkc**^h8uRr3^rG6 ztBB^}mGSPZu3qabZN}N9i!y<;s`8bq zRmH2Xm;3V^TlP9Ld||*m7ws< zTTwg=$bm#Q#Dw@ei-0mKeI;n##1=_Ed}I{sKc6&AzTqEkjhNC#z4x*%i&B{ZK$-Jq zmvCr!a@k&5^tR#A&y#88Yy6K>W$87CucbRpv&$Onb<}l?(Pd?Q19D=#U=k!uizMeE zA`)~SGN|@NL_~J#1&Zc@GZhA`{92U6L8^ zhr5ghbrwphgGYWI=z{;AlOKoxr?j$ix(rhu`*liFH*r_1*{9i!EMpJTbJOB+?PkOY ze1IGn0s(mrHJ1^cN-1{A$%At8;>sJm<+VnP?-iXZidhTk=`%_=;{q6BfSd%Va)7_f z#%{!UJ>os~qj@PAHT2{JPr;y3R%l^Nk5M9Jv`oEiUz*z%Kp)UhfQuh4m$HYD!+mw1 zRnwoPdUMwyd3En;DfVhUx9`6n8A1!l-OdumV9*(u5_-{(I;R+MUY>VmKsAzKmx@S; zW%F{YuL?jfLCyN2FhUJjQCTGxXi0=X*-bgiS6C|~mu<(CC2|)S1932C5`wzDC5SYJaDBsBmqYJ# z`j?9Pu70N+tAwu-B!_GdX=Q{y%C0kk^ardR z<>%`0KJx>Li8Xx;o55}1qKHd@nm{-jtP4h9Rsqix|FM{0*1oBN8@%goJv9pq87@1$?sZ%hpbs*US z_2b#iMt}+ht=cpDRnc8GhD`nmdkkj9o_W=&a6kH9ZoGHz(#q+9oER9e20y-1C}IPS z?*U!Q)dwHTY8N#3Y~SI3Z94ge`(P~$xgj}8wyH&A6$F^2z|d4^8p2=bngO|JV&ZEY zI$_~yW8UZ$@qc6k?(fN%Kc-ioV31k7OL+!tvXmsC$-&iK$8UsswUQ zkp68lQ5@#jBw-xxO_5fPqN-YsP5?&0ErU1@sh~p%ludH$+b$`;FHck8oN}cB%a*l3 zsv$h2l6>yPAbp~Xt581(aDbX(_-pu-0AUzpbZQhdd@&?3YGneXHVP2sa05|PG=L0{ z(U^U&{O5>qjh4AaK?hpPQ(qo(WG#X<7G+b;f^Oo!f3K3Hrio3AUBCe8Vq}%0va9V` z)63adcZVp3s@L%~{yYu->UvLi{@~RVFh^qC7oL1Z72?`%SK-o%5xup)D{t1^v0nd& zUG%j3=cayR&z`;V$WM8|B$AW{We{-B&MgvR2ZH7PAO9cn7q-M%Dn) zSiHN^q>BukfjWHXPCHRlrd38?E;f-YJf#nP%`o$3TF0~r-X2{~X>RPK&|*?&cqnL(_F=ee3yMSWc)Rosmb4jIlm{Lae^l< z4chI(H@|fd_rGeKq4i(HX<)Dso{!diL$kl_8#o!jFq#LvMhF2Q&qUz}j)iRL7=H zeadllrW1(Q^&vS!SV+Jth$;rxn90nQ!#=QfuUz?)!;{^y2YtQztE zV9PIpMS(S+a|cOP6Z6=9yz?tlrMdQJnNudgul4V=J|6t1Dk3=-%a07-vwbtAW7RH3 zjsDF+XJ7NoJ6lpYr}nyrp1z%x;pRCY13@GBGRl(>5qQ)Y)|7&_P*TG|jOBP!^h#Ay z$7~XFT>8cc?AYls>p#HINP$ zXFXd~>Bl*|vyp?M-Dn<@k1!XpZZ{mSnjtsV^Ra$?nH2>D3eW{Pn0Nu1!RcyF~*p#{T8@_$yAvqF|1K)$# z=_!}#IBNm7F@`Zu>Ns9`U+1sYD9sGYvo}*VYFCx3f=1gzgn*nRCx{`zuJpuZQX8{7 z0i!~%H(Sm**3QKH5upy&gNRcFx7Ts94)aBDsX1-ihK9sGtVD8xW$lJiJ|TwD`_cd{#z&K=3)b+~YXxQ&M( z4Um)I;fCavKqE59Yza5SL{M4%WXKLEQYH)Z&wfqEhwhJ7lIwbP43%H45k)J;c~{VuOHHGO=={rMy(4G4_#h=KEi`@#V+i2bC% zCT}axQ@XEv%Y7*R#Tr_g)O{*Rt1=7UP?86YM}i3;AO{$(kZS1wgi{EWZZ7y5yy)JZ z)wSg48Dm?e)UYYNEs7<9^X{`vyKKz^CxCthNDuPhEp~vpx}9A7I26&REWJZ~2!0 zRksnAD`LN{ys6ZFdwVBV?%X8J}K@I|Ww&o{btiv;PjWcJ2-l>SGm$5hTT(V1)j zC30|qv6`^`bQ?iz18*1+z{{WL;B3UKb(8FfBdl@! zYBq~~bl<&{l*g!#{DLb63DG4krWY44A(U1^S0kr zHN`)wWkM`q@IZSC`0ZLNLEK6ugHO?C8CUX-RrQZHpG^t<9YZe{CwYvgW+utnh?{l| zfGfZ+h9Yra$KkIBeDKgs-C$tul}iQcO7SP6wHJ!yds%qg17&^-IB|ZR4>-<2v!DQU zOX@)jCg^p~E?K$ty}D~B856O9zMaNM*+FVwWQ||mjp~Fi@z7EdRCY^~`UE3t`@Sp- zIH!6IRB|fmQoVA;P+WA2lyTdjt8$@TD(0zq_811TK}Hw0{Us%c@A%#1ej4PK-m_v; z7;be7@AGc~M)xBD-t-rK*rxvN!p*RVWXL2UCL`4rp1&a*_phqNU^c?yP0gm;x}`&7 zw9_8r{cr>vV@E)rv?Pgp}thdTt>n3;E+(m%>ttE~e$aZoe@ ze=Yd|2m}7{-CnaPhc*@XZz3A4&AAPVC2H{C%wE zL1A}wIp>?BD>Q4*E^Hkc)$XCzP{M%z@UEa+W)jLtCw{6$xLAbv5T#-zd#NI@bzr(8 zRA}}WL`2SQB+xB_3;_yq0}*K)$n?1En;+*T>6!E`O>*ou2)NW!)+~r5#MO4AOGIGT5FIA&#;0! zD=Aok5hSwyH_kt$@T*+;u?H9DZRB;a2re-V=P|FT4uH%+uYV{Qx>1AJ^Y>puH^$0- z9V?$UD*TyP+V}Wp=)3o9O!eon_qx2<_d?JVjprhacG`=LNe|E@`Tu{08_q>p$2;E; ztta%<*n>@e%2*HibXive@>_^il_y@^c0c`bm%2UH>tf?9w^G)WN+kJT5i=za?aM~9 zmA-sX8vweJB^u@Qn!QN`O9yk}pu|J$W!q6(3%U>bcN*^QAu`R558|M_P|Dh!D_`IjTfF}wD7k&2l017a(O%&N{}5XIiIggE z062L8CV}grPZ5Y~t?Ut!?U%|@;b+R{{j2pR{zz094%t5|; zeiTBTSVb;BD>rc= zXK^dte@1z4f!!t=J+J&3HP5hBPM6qX{ah+idoDV3!N_w6;T(Bj{W zj~U&ki0_;3Ikk@LvnP_wUIB8TGe1=0+Tn>P&9n}i|4yW9F!M?+TC|6QxgFz>>Qq({ zHK}>?>G$e)s@Q~BU~(cT)Pis5VFTiW++o|Fu9K)Mz{04F$KMbLwwM#vi zr$-tVqW-+(RQ-+PPqM-|+QBEXsPpQm+$xFEfp`@lh{7iY&H-ZSfqt`);X?ZyS~Df! z9-N29t{2|sUmAYd!I-v z?Q3)AZ)tM(Y)gC2bT8-$em;W_c3%os;Ku+|hh2Ni?;h^%RP9Qn@9|zEBt4sv*D?V<%IVy(9&v|$L;kFQRp7^zJa-&*& z*WTd&4nmg#q}h{*+GbBy`(u83yPIT6*6Egw@j)m|)Qckoyj#Rx{1KdlIG3Io1OY2oAzhARiYzy99LW2eSlgD~3L|mW4hy zDfJan&n4vw$no!?Fvi=}Jvj$cU>D)Hqz6zyA>ZovVW0KQ;-v4_M?DzzQrG-sLs_5w zBid50QKrQXmtO>&MbI((qQ6TIv0)3yvG>`$20E0=O;3X~I(Ih8o#MA?1rK-Xw+SQv4jO5jcd$)+#^~r{1yiW10t*AE&G6$3Y(k*L!q;R=_W zx>nYWu%29P#8EpUatCtft`A&G_je<LZx6o zq0C|9JOb<&3?(|FRz_C`Tc+JgbbIkG%L3zRQLp}&5z>8J8my)`Ajb=QUHJX_g zXsFSs>29LoBcq@qBZ(rTAl1pGw(2;Xs5i+f$KQw`QRHaqB$3zCRe_Ou`TyHm`QdpVaejAhd z%pTEaCG_=J*e7j&{?|HjNRt7XN63fy1qO-wi#)4gxG815g}~l|uHu|Di!Ix`Ju@U-9LrT^Bb^v&+i2?q(ibSEUN{3)xGyD6*4>WD zw2ZAh1OF=0Yv#_JbZkz}_n+G3feQ?#+C%W~&*ek_fe&~bKR!^r2~WP=k^9P|xP7N8 z9O)OP?=6W+P~vXf0`46LXcz!LmZ@!gI0A#R*#9RW23tG4Jp4V*HSVo4eU#KW5syCE z7LMDdRO5yY)YY@5TspfBw@)wDjzfrfKXc1PamVh3_U320hhjgqu4lgw@&7Kgy~*hZ zW;tW>fM)-YO4tAt4#>c*Aiw&yc;@pBbNAkLI$O*ldqcOd!{hxai@0!#K;Re?Vu^u* zpo_~toeb4eU8dlXkPzDrTlQbrmcLKT+{19NA#c~COZh!TX?tR}e7(DZ=-reLoe>UE zebmLWSrVl%C7;&N7f+g27PpRvHoXmx?xnFQ6*un*{G^H}2Ix)abHw2qz8SQ3fHcxR z>Cz8}%A5AD*?hI+X*u=SEmI}+JstUUyACG|-7K1cK>>wW@cXe8gLpvye)D>79W^0+ zaP&Xr@#eJHI?nophSbY{Y%JE#XgCeuOMU`b%zg~hn-AvjG=9slGZwz!dA*O9w6 zUAxf_e}QAP2C3?x>JZ?UaR9aa#3lgvg5ek!9gwp}a4^Zi!yx=0>jhj7*phePOa6b2E`*$;w7&@vLabcRHPd)D zj5ATysL}3Hqs{WEPEXIS`{KL+X;na40Nv7HTCxKwSO7-#t%zoajw?S_%c}b;#p$38 z!)SueV--UYJp&YxY|+o4ZbSmK*@2v~fg^-bRW}f=sCCojnVX9KVeAvP^MR8~_D`OR zZHhk?cY{W+1$b4U4hO(5t>se%-&+-YG)<8!pve1-79))eBm5rP!z7MuG4V6fbYOyir?t(-yo7 z`b(CHo+lMwc1|$l8?N-CFK6gg8|92(xX{15!RhI(CGVhojQq^C zWfj9@gAG@my)V4!+$4Z_Iou?Cx@_R;qh?l_2`FdHzBIzo7EUeuYz$ksE+*ZbzuMV%hpwu`ch!HObJa(KwRDdf3{4Lmn6 zK@TE*1VBAYz^&b;%q2s2#@zrk+V+61K=BQnSd3=D<1iS6~ z(2OY{XD!01Isa7d3zMoGCB1*w_`A+;|TH5_J0y z(v7A5eY_`qg0fc|d7mQaxl7UG_}{FKe+p1S?-!k4G!TG=fA14S6$F^)FfWIzicQu} z1JmVjoYgO#IK#;TJr1*CTE?LIPJ0kgpgiJ$_6nDqtw1P})5ZCZY*E9KVOWiE`~^|r zt(F~!*^`8QH9GIr3E#JZ@H~$sh`z#)@53dgllxFE-a6x|)GKhsJ*rC8e0A-8mbX&q zCLOB4uhY{Npn!NmsX0_@IB?0s7q@+JXV1Thb0tcYdALd1YkWAiIEvajqzs*RxYTb6 zcn+X_EB6KEuMcs}-jA_*GWtj*vqh2Sd>NA9Q9XF#-uU3Yr6pU;vIuGtFh3NDLOZrfdyBy9QmPv@R6cn$D z#f8{g*_8{z@v^u5SG5!pXxM+n)UORyns%{%2ILz)Zqm{Pcz7S2cQ(g0$N!J8?~doX z@BX(*wi0Q`Dk*zL*(+pMsAMFORVpJH*|LS~tZd5OlD*27>^-tak?}oz-ahX8`~5v0 zzw0m8eP8GCetll!jOTftbH;Tv`$(}en$){bK4&b#==mg~grn+vsj;eSxDd1=3^7L< z{kFqCB9WKno(;+J=88`eL!gq-_Gi6%{y*y%W`|?1H)ol9O#c23-;tm$cSe85yfJa( z+{SLmy2^$*MoHyM&lB4h@35FUdX{B`V2ky7fT09CjRdf(t!Rt)@x1U<Yy_=(!(pF}~!P&WZA?89`QXBO&yz`ZhN%yayl%r`Vy>o#65V6p1l zFZ!)j^+KQUj|mb9Qm>OB2c!ywhyCFnI%IoX_s{L!AA)hq+o25?D* zy3@6Y#HsFqfr4n64;6Y%9rYx7-&)!p78V%%89RUE%nkdAinv~kNa7ba{KkD$zOZ!K zf*j1DM$|$+v?fIy0j+f%mB&)N1n&~Yxr5ng`v%9}tE}JN92t;#&zHA!svH7lX~^Ro zJU3^gqW~OR-0A1dCvF+058XLoO!Z^ptiRoRF_}qc^1JNr+uoIYkh+CAth|V0T2O!d z@N*Z(I)~0_>k{!qZNz=!t9iAAKilAc?GNdnJEH0SZ7k;dfh-JgIr!YvH*`dER#Bnp z1z(r8oI!Ryu?M?VW{Jnc$_Il~#X^tq{PD{G2NILu;X!cGVHih@{5lg!XX}#2~yD7{@`=7sc1Ohb7&6LubXaW|I|0w&*5NN zH|Fv;|Era&YBl<1T2o?W3MQ8W05Viu`8NZtEFJ28Y|tCqXH}-1&?U8!h{4Cxs&pVu zDKIFwySjPvDJ)ZBe~=#vMi@ip)52x(bnYltOYYq&zpQ&>I>6=vTOOn1Dd8F`j4Nvu z+q5_xAO~Hmks^pcN6f^k--PtP6-UonR$RXJr;qZgny`pMU}_%sP4QdD^NSe7q0g%r zb#4H9$P8IRRN!!_jAWd(2PM_Tp*C!{BnU;(CoN+OQ{}1&_>Ec&*zV-zojA7Ckd%mqzQD$40<~ff19?6yjjD< zOQro1+I>t%NNDweH#1AohN9Eub;phpklVi{C>@z~)Wb%iZYF%q&2nYnq^7rk9--l# z*GsRY%nQZ0)UK@rt*mB)oFpeFC+bq}AeF1IjcfF3cJA?#R%djzP968bNj0Mw*pe{( zK-25)+4Sz`ALv~qDFy9^QQM!eh<ZGlOX6d! ztTLa}KFAME!%@0!=PjC;Hy_KUYVWX1`emajEu+ruRQQn0w(C`YUwm#tJ{i1~PVk0- zwu@A}M!iJ?&aPg&OmyV|uea2u!?LO~wFU)zL@1|YRJ=d91&9*=%iJ$Xf>imzt^89# zf+|Tm2EL6xhSUX73^FV%41Y{fF=~QK{+IR%J9y9lHuk{fSv#olc`aaWEt{UZ=-k9B z##%sYLwcQZ`Cg?ChivVyu{6mCFAiNEwpRbbDiXQ2ALTmL`p;P2HGKQj=AWx6GwHc- z?|w}$lmUS2!i(6xsZsQPHK!Na#a!f6;p)A!!_*V>%Q}1%^DDOLw7fS}sh`6nq+~h7 zp|d_J-d{ne1#mul^m(|V%)A-a+POq0%mlKud;%gn!%q<0mHA~LAg7!MauU1(2ybHx zTo(i$+GFy5$U7Hq#O}g5Mk0dO)p0rgxo*`TeEA7h($0_*KM0%>|2au*CZNG0})r6y6+zv)%$oy6+=VgZ2UXH=?w!3BDHvi z=$4pahbVo`qL`Sd`ZwUSz<5<82z$SSRx>w3W~)a@zJ=h>nwL(eyZ+8$rl4(5+w7@f&fFI z-iKoZn&@{)_Tll5{p=VaGz@iKlwtAxq`pcE4i_(}v|HlwU$N{5aunDW)NwZ-rDRq0 zE=XnjJw5(-Fyy>$vcdqBm#@`>>J)~KJ?*N67~lT3bDdE7sT zHz!A75r2W#%i$-W zq$@-e45IM}ML;C_;nw;7vMvb(CmBk zwG4`msI3|cV&KbG`FD!^sna4YRrF(*$HY2KSWL|)7!v^#hf!t-$*tiC<7D~sA@c)= z3)#ZS&UWlqZ}37{tV)S5)8GxC95K8@`w)JgQAYEC__8#Gscl>U-`-^DYPaUTXZdJ$F||%%iI`L8hcJu=`Tb^J;^JIU&|5y+UyO zrNQX8@Kh^`QnL!x5jUV31T1ivAzi?7Y@(_IWfpxqVCra zC@}h1hYN|YGQg_y(g-83l;ezi_eMU!kD<*aG)V}j;APWmf6^I<450l1 z(nP2Y)FSc&wkk$^ru8#|bv`aIi$0L~vUY(T*Oe*%whdP7*0a0+c=k6MUL@)VL`5Q{ z`~L;t9Ks`LQ0HLzsM7t{;zBE&rB~&B-@N1_ci+M@$we?7d{3BNjxr*(i6n(}QuhfpTrJzw$>+bjuQDWLoMdWBkW0bE)ye4fHup9M_2xpPDY~{G4*8&}FT| z=l9t(fAWQxw|sacqUK=!VBjRu!DIcX4rRh^ADMwPdShMQQdkpnm1q}a6jWE2chK#j}>dhoNUaCyzK61$OJ)&)nP!g6^T}M z$%evvl;a+9cE+z3++>7-*@Rh=Nisc%p;7%r*utX;JSU*qBj`rt4|F~>Ww1e$tQMPQ zwsBTr;W+Ot0$D@z=g!~dvjTL_C-SKpgXbhhUGVkH!I8jas$AL%J9*VFBD8Ux$7GtL z=TW}u5ayMB6Ip_4nfS~z&%tv7jw2Ee{(-bM;t`tkiCPF<;4b5^F|Loqy8k;>HT4aK zxDjb7hf>aW(|W+6xx{z{5v9{~R1#D1cPO^Dd1XPr{P+sndolh5+X?o`;Gc2|t2*9& z7KBSHf^?owy&L`UiEdByHq>wTKa+G#z#=G|feMcu4#i zjDUQg9PQ4&&%Yma|06x)HSDTj)oZ6ng(nl4Hgbf^jKu<7a>e1w!5kIjt#`JdjbYYe z`flFI<&(<^t$lcfce1oApPoHoom+@)FYV&!NI(Uh*d?hmE6yLrxt9E_JiK1b+iU#i zvZ$FO`;xiudr1h5&wJAo(9!=r`4e0w^pu{jk!YQ0PR~feNm9W)p|wtPN7uaC{d{HN zn`nGJ3r?l)3nwpL0M`e?9t2umNBHCLv+x<>E>`n?ZI_Of(!!kT(7sGb%oO-hMvR=+ z%)IxtDX^)42nYe|!F3!xDo(F>K0!w_bZ+{b@af6F3s`V%(0=-%IXdp+B9t!^fvSB-9JhOM1so%g9K5h zw$zUPd6%1vm~ClrEE#tX&gHpD3~Kl`waWXU>O?!x&QncHKTXF|(g zl`k`&Ey5%UZ!R=1=#=-D;tpt9hx`{mq`#3oZy_??2VQ|@`bt&P`&k0)P2<>>C=#=H zmAJ7%lS{jM@0J-FYsG(o9F+4SaY{Ebeg%#pThQcE`XWEph44p2J{~15+4VB^%KVKu zxVvX`S#ayX!G#2n4`zT1Dz@Jz6Q%n{jtUNQ zXhsM;df6dBq_sh-5HEkILI)TQVzK6-|V2 zUUlAnm~ZF7W4c=XXVB^Pg6G4C`f3-IeV0q{(B@n zb>Bq;b_K#Y{W*`m&$QX9yw2Z;6wZ^Sn z*^Kba7MSd6q-`1;E?p3bBOcM196AspN&`H{6ewJ)$qW4dZv-)oZ)V zS=NOWJ-UqDyr4_Kla;g)O%t69q(><2Lcvn~$!H@$9K<0++~eVbGtb~5=W+ges2PKF zW>BQ2|5CLODNY{Lu}VqvaUgO_2vZxb|Bv>~et(m%cj{m4cx{kveEY#JdvWEk04jt`Gv&^dw=NQa5xk5h>QGq9n{`Z?&aj)|(6 z3OOj8wl|v*G$7M=;vW;^O#WE|0K+-{QgR&Sireh`zFpeSa@6t?SM z|Mo7o`RGYp{`+kh|G+wP0BIlf1HM3^C2|jZ|1cZtQm1=G{CpWXOfwcKccs@^6!%u0 zH_ij!4_R30`*;X9G_O1O;qQEojAS7bg=<|u*gpcm}M>)GFoRl?A{*@_k!n@j|*m(TBahkp&$zPD; z7dV{a9QY26ztnMRW@YJq51kW<>uAtDqmk%UV=NlRQAkq8C{}=>wgc8rf_e~{VhrEm zExTt&n5<^KB?!<7y5Uf&f8+lq*bAs`3n9gI1LhC9OCSZqYw2jOs?G!Z(<|*UndvFnky68E{4Te&F5{w1 z(K%-loO`-t;ULEg8-hA-&n9#T`ExO+_Lr^bSo5$x_sjL`UZN@I_^I)xyedj|GTzmV zB!S%i%sYiANtr1IT^uw45aKn}2dB+H+3#5ufqg2*tJ!*!Xz1?At=^A|TI=O;2?uuiu;={y4fMWn zL*%M0oInG}yCjAAdQs*SOX_@ydi$C%@@ zus$s|HJR~L9|bu`Xd=kSR0Z*&nIP|{dn`1d^9%cZy{f3MU8?;;xYl3U`Yrj?#mEr5 zJY^UL&QD#PhpwLwI~`zIJZ>F-p_Xi>vi70b&GOj_o}X+kMjNt|$vNRK!L09(W<}YF zY@~fHs0Smrcd=}w8da_&o4D8Ixk|9w6>Zd3I~>f%nkOT){{V6(!L{#p9;m%wp!Oi@ zQduR5Cp53Q_$rR;`kR%>|{&cOn_Mg+sSO3Dk2?PoWNl;%XbvbgRR(@gL5&6Sl z=ys{tgi7jb!G?GxYu2~CXpOUcY*tUnsqP*Pf|HpmJk%iKn^qPQI9~q6YtsdWH`; z;1);$5QZ=i_JHh+n0E`@mQ*Izx*9WlfkhviKmUeB}(f6v> zoauQii%@Lu^x1Dt4mS9=*hxeD?^U#s@RJ#N@UQ~XAk6_i(@^JDfFM2aythl9RF<$s z#Kj3(u*shc$uc0N_n7;N@At}2tU(ToZ zxKAfUv=%Vz)(NRUrWKHL?)wEGhcY8BK8LODaK&-4G3a1$I7T3bGA8tbVWcLY$G|0X z#=w9vd?=s-)#}bZEXO(IsoIXeu$Ipw)z)WOFR>RKUc9>T^5@Ei z{eES5Ptv(<^w$cW76reLg|Wr?ETVZM63(Cxp|1zR&hI+<;ju!$eJ68pmUuj9j;Ywu z-(gIcW;^RCyfxX;Oi(scO27ZZArFD_*E0IheWw2lSozQXi2MJ?0a}6L(%DxukROkeU#A|U-;lHo9Ko0L-9Q)EFj?q=Cr(?o{@41z*$v?CUYEL+3 z=U$$BezzL3wZP^@sq?6CGD12a{hX5hU#my{^2R59nChNwdx4=X;ws17s0Q0EAi#$pr{TX4 ze-dFTp;zyS{tNZT!4E)n5qje-DEMB8JI5TA;>@ zgQ6Qt&7fOWp5q<$jG)j@CmFS?Eouy=9c9WUncZ;=`UMvsw7?<%vOgBBc*yP;+OMQE zmG_&yJo`Cv1wYuAlDAx<&8$VI(6d;F@+~MHDQ+&L4OKSOQ!~NFpAkJ;Fx}CgsJ{*t zKTfnyihWbpQfy;dFIhBlYLj|l@T0aqrHJ!ik6OI(detQ(Ze~@gbN6pah=ZftILvhu-}M)n{%MipWV}Cr07z`P{kl z#wyxNPv?2pgKUm-u0QQ5Ku!vplA+{291Xg;n~M3&bD*1uBD~ro{&}s}c9+6~iR5q3 z`M6|da7{(Q$$@DuP<(Oly-uXd39R$?-Po37t^JPnyia(DrdW!a9`+)NS!AKIVs33q7pcp(A8t#>cRIY z%*&?O#5iN^tHQ2Ua%M)Qbe!T7VBdX=S#H$)NZEo$hE1MAESbAz~0UdL`6dY!cD)Kg2*+F>rc#`eO` zOUz>gv$gR!y%ip8pH>!-A%y+pg&Dp`klzAnJH*NHb9wW4n=en{g8{L42bnklWnI~) zeDmmcnRJ2USu)4t_S0yG<>qsVXk&>HS9YJD?iJThNBu|c>**5~YG*HzG~U)@{P_>( zn18N1_*4Qg>lStF-OyzNaRwTu#PPNURc60m8N^8}xOL9GKBHuFc{sju%I;3t8yQw` za-jSY(aAs4(Qj)L)9hUTZHgNH5W}=m?U%$#7bD1Kt~5WbYs+D{tbS`4#GYx)Su2yPX~bO zEg=AdYfwJK&rhgrgxjorQGiG!O=>0Yb&_|LKBhSN#j*3XjoJTh4;KwDlZ|!OofzlEqQ6R?yJ}OE(EPq3V2=M!Qrrt?(`%T95S>TOC zDm76)U+ywA&z6-t8@Nk^*(q8Ca*_hz{2gc`_ZTz!d;T*#GdJXo=92XOu){W?AsKkC*aq@oanF&frxD9gB z{D%ncN*%%*cO;7?$H2zK6vxCmhL}qn92_zXQD!U*Q6QBcSeZhKeJkVOzEWNzFn27e zh7Di-yRJ<~9o`g2jGjUAltjR8oN4~ywe_9!x5QB|!y9;5m}DebdVBQ3q9=o~m!-`m z*YL98+wdHr(tra=YY+cHU0c}aI9|RJ#PMI-u=Ul7Gg*}8{!L1&q|<~d5RO^r_4&SF zpg0Cl4T6|%9~JkXPSWaW_Lb4RmlgNCR9kf8n?!qGP)q=wFJ0=!N^cjq6wqxJM!p{$ z&q@gT+L}bYXX&fM`Wrt#!zuK1KIhHE()g^d=o zkf4waviwthQOV%hX07BX#zPW!F-u%Y=L?y}G|xZ|rj#L(^tWEL(zm?eJte7;{{6cR zQ;Ba|EJ=h?WR<+kX=D6$l8;SHGkstTVdN&lVA%;pKa&^O-_$oA^=LaSGzkx=DAIi( z=pdG0%FT9+@MrnlLpAcbe*)xvd_KL3!$ zTem_2eoBBG^ngO1$rRG63XXv~pUAP0t-i9QfOzv#Dy_*1?v04AeWQa}#jiv}4Ye@9 zsKIMS?q3nq=^?zpndJ zF4w-_BAHP4{fV7;t+cuSyBI0moHj|6N6!67q#LCd2sbOQnJcAR{Hrk9{?8xM%JQE zA^j*#70v#Gx%%Z>@6X>H^)k#-bP`mFf-wo)4O;Okx0wQR*1#Wz`78*av3f+IC?20% za5T=*&mt&wT`m5t=NN@1-8bDYg09El(}$R{XP}0^nN!--*ob}8)yvelgPuWcy&)k}S<))}%&b&5&JlCvORoqh>Ku=l3%c?f1L?sq?+!S)4}`>SnHd&-GN*qS*EAScZO1ipjc_v0Vh+Pq`` z#5`|*Wqpr&xGYP(I*E8dOyVN<%`2kxMe5xHngCFUNedp%XZ1&b8`zg24WS}wN~x*{ zPdXZ{&d=Xy)Hhms-i$vZq$Eu}6`(b@?*qX}psweaqkLNG1q%Pbcjdg^VR`bNc#%0P zPJEy5^4Vrz`F_E7U2+_7I&m(6LoHtjS_uI}xb3FdMI@Ol0u8U_oKxwmV|{nJbE+)O1e5*sNk9*IRDhb< zgFZKgzAFoxw$p5+R5Ssyw14TX=(l(s_`2-u{61joE0IA6Aua_*2=(l?Q-}|GoWS?A z={ll+Oz>D)Nqm>zD3&=E14;C!lrMYB}GHI(I$| z{YsXb=fA8jP`>hi{Nj_FNR)j%f7u5oWpJG!ibq(n`N-fBFyW#niJI#6Y`+V!&zQ3f zDfT{d4lP!e^|3dKdaL{}ECODuq!e5dl1=9FPmJRtNpQXv9HUiv%ox94uiAGaBZupGkv9fXExwvxi_$P zIk*rKYgGvPbN!FJXzs6b{(Szom-s%@IUT?79OrPi_H$-$f)Ne2`Zhe+}0u@8(MLMD>0OOgie;>=(v zt=)TGt^WFSly{3%=%Hz9`)L2;ouyW_8Q02llhR<$4p$1YG>!C3MU}Smn^h&CG@v#1 z;kcCF2-ptCYEBWlLd=y|l}Rv0$K8MhUm#!oVegD~q5iz5{6G zX0;=dPmh->_3sn29cKk~r(ebizb0j`dE1}nS??zH8~Q-Ep~Fd)1HtIa?*83$?XTtK zQI2r~K3a>WAI`&!`JxM49hsL{>tBb&RDv8N6A=$DdJuJuV4XLU^*W-?y_FHCu0MO+ zWK=#1BQbYGc6{)Hk9^guK^j0&0XhL+?cln5{6nu(X zvWrZ#j$dyN?{2nMfSfodOe;H(3p}E$GTLE=1X*69cJVjvopV;?vm0GJO`R|-G7#04 z;U=RF*N+#p2HL{ zpsS*Ea39PWMLdgBN&4=eq1!nC_(+}!%MjWpmt}n1JD#mTeFDI0^Jg%0!UY_o<5zY^q zzDngJl&7sGOz4zX4K4+Y*bVdoyY5yew~^KuXUEy+TbFc1I;5+vIvb z!{mw&z;J?ak_#DwI1k`AvXA0bfo;>manY`ee8u+#WEK;0e?D}i?2`^T2#$ngP(Qo=|Yni`&Lg|6C;di-S!HUus@4)6l3Ic&uy3)|v6#K)DCtaABUD3iF zUO(0oA69?prndFu*c{LH??>5y(mLKx>$TXYlC=PJ5PRGf&ZN*GM_a-~9dlW7ZFhcqiCiE0b)l zOz1dr-#oRCj|d*ZXDRji>w1V zph6&?vTq^!nOCu-R?lC09Fi`3>g?^t=WYN1Auh#x*fwwi7+{F2+`}v>y>sQ}XAI6{ z5t5=uJo$g(W^HVYwhVS1`H3~mAc+Jx30%>G{aiYVAXcSQt|;m(?&x|;v$98ztbLki zuqS`*mQ2Evmn&C?Hjeo1HgD}@xnuprc8QqY~=jny)>oYm?=M2+JvvMkn zE{G0tJjE^5@v!o-U>RuM0W%GQc@Z#w5UG=eb8h@B*wy`Bz3%PXrz6)|eqM}Rbe;BT zkL-L+m9LAH90gtoG+VraMVhBs@KD;jWWf+F4NLV9%p*^yq7OI=OO0s!wYLlOtBI z(wXPK>C?d6iB12fRrb7!bpHWENQVr13i3y}ZQ$&!Vtmsc!8qTbX)3g6F3IMvpND(z zqHxNyljoSFmx+IWgogqBeGrmIxC=R|l`Wt!;8pzZe-7M>p@Ty4|1TE^x$he~9K84~ z?kBgbjCu>W7fxyTo+M3PQQQ*`vfnHn!2md(gA=AIqRePrF50cqA(;{^_t|2pJ7p+% zDmapnYG!H6220K>@*NI^wb*M2ML8h*j35a`9%wIhEB1^}&OH*MJX3?~YeF9Kf5;g; zgQD_UWLO?v$W8JGxSCrWT5h52sIvztAvxqc2v7`O9F+gGc<=)shOP+)~U%m0(f_&<-pKFSL<6&|s@a?4}dP z@cro2cv<@`C;|8(CG71emB2{nkJquNXQ|Rx^}qilf>x@r!^>fXm{^D zwVq-ay6~{`eoEA`k@2v^XLI5Afc(NBE5MizKEHD`yZZi2z7Ex&FRLZ9i>YxS?$RYrG?WUKII2mU^n6=$+@*&*4kkcL(HNt?mb z!^IMv#%Af0QRN}UpwEaj9{0yUiLlQ}-m~8juPzuTenzIwl~QZFcY-;KbT`7lBW{CgN=dpLYN>}Y7K`&!cC zE%Qv(*0n*pN`2v{6C5lK?i0;t83_FY2c(>MK@JFr2xBWUAFa%kc8UCgZQ6eDTbR#$ zE84xp*jVygKDqk&(5J~zqC8_pkON->@%FmfPV(d;Tfi!(v3JxXg%@wg+%# zDD6S;;>kGlbEM(w;F<~|Xl8*xiOS)T?vS+n8p)l)`RG|MsjOoL+90=2$wr;`=cA_E zi#&s`*{&^z_j&F`n+AR0qwn+m_}q=_?UgHfBHYuxPe2Z;s1R>21%O`!R0w+$X`;VU z-f&_|_O;Ck-qZ&=iOrCTqbj%87CFJ>fCoV&@8PW1+@p5)`7tI^-R#tVTh7fzt+T|6 zYyIdtK4~&jt6mhOL248Y?Q3Cb7&ijZEF*9@9K*AZ-J_8&O5?*?F6&Ws+?^*VJH7rP zZ{Wje%rVK3BvlBu_@GH8Lc}i)L?442Q$%R46v>=+h_O3iPi%luN?o~h}`LK5820+D19+YH0*2d8i7(@_Pd(2H+FmqUJduLxF_g-j!ajfpT;U}4R0 znQYWH&}7?{xo&kmjH5bQ$@hDRp}{L0GN2s6Y|X>cqVX>DLK7LH4PMA*rI=NRzq~9i zNTuFvqs6yM&8%n6ZDd*&2vIpqwG%`@m991PhQ@JsJLGY0FVv5QU7zqMAnTlHa;SVO z<$QVYxlXGsCfqY9WIAjLznF{Gzzg|Ku^eCUt9a}UH|g@89KSj6*>3&eLXF^FL7~}5 zCqzFG^a>)#b}$l!f>Y@$EJtqkUCHOdlZ$6-&)862wUS_Oxuo*@gY6YBAO33ieF9ME zjv&9zKIj9)X=^aiPe>hKoN*G(T5V30;dC2&hhy|b1AmcOGQ4pYjqE1!RD{0|{-PS4pYA^=KI@1#TRZ}C(C-*wyw>lcqpeR^6S$`{{66U?ro>Cd=F0aMG~bFe zCp(4yyBK#Lo3^K9Fx;^g=OyH^Ac+N4zz62{Js`43_voEn!PdP;o65(=esPm}Ph{V? zW7W_!MA+~f#=NXKbFP)7YqfSRoGux~T`bS?7>mYmF zwTXS%uaYDVJR^t+5&mg^En1F-=9wEG;q=xpuPEFDs8?ZHFgKblVEa)ePX- ziiyL1qMniK4tiHO&i`G=%>NV`l9od2Myzz(&%lMYOFX%I%jt=>E8PotwqnwdEJZmN zseq6o&c#iJm&^5_gLQm~}_DI%;}{jvpIPmn^)o)5UJhs46| z$he`QniU}zO^5aejb0oifv3)Qbe}$*kUC#&YRL^aIyZGhD;h^X9nca}!YlkXZCs9# zo=igp&l(qBW@Ip#>Di9OjN^42_>LGbRZw_%6YK|~{iFpp8+ORIrcLyHoziqgg;X&H zeeO=za8zD2W$3zB(h58?$wPWtUk>_bF{-1279(=m#8!mODftFVo!y=03Zukz>unG>H|c+l2Fi&1SmCbXxn`6Uz_}ki=vXgAyzuK zho{VCTp2At=k3-f#%aurizR}sgaPM}Xgm1cmo>C)zV`Y!&P(z}>AkCo{hy@Cz0VO@ z{8IGsdbgc!<^5&q8W5BK?}zHd13A|tp!Oo$MxK{7R>_n6e|VpaJ4E8%=9n#*-f3lO zsQA04X9xKOpshl>`atee07_@VTip?73tqscw-W#K(M#q7DLadYtk{YAgcb>r(~qC% zUj&3o3ThgW;gvB+_5|b-CF>Qx`3`bq&E71KTxR`+vn)`WYtUNTsOUC-eRHfGm_@UeL z!8T`mqFswGAG@-wcCMc?eHYN}La#t?O1mCA8@T;+(o+EA#C_#WV3q)oj`Cy%OUMYB zA+R`$RL1_Nd%piSiu7^ds81Zh1T! z%l>G3%XUtKeV;D=s}t^isUfz!F&fkbVdZy-D48EfS0>z*E(E#;w39_$t$#>~H5~Pf zDsE^q_fosiOpU{RtT$^74keb9SUq8OqStjU6wnkvG$jSt8S1FJk?zPKC+u0#%l_4s zF-AR%F!!&KhAu0c2szoexgYnXOhVaBz|92mgaC5220PK_Bha@)xZb;LtU3C%_p;{1 z#`)t9wZrQpK8rS=P{bqp0fbE$nZ$=E=D*O>0a29k6~8dkc`I&yJ72*$OK1yD6^HM{$7k$loOYyi*|J#cpEUvw0}&Dy(JM6pt8555bGC?^AIsV!6oWI{E;g8HOsY``xyJ~I#7{O zcOdPk(aVMNn~$;{Uwqo0LLTt@6sbJ309_dK1nvXkf!V*I;-%Ig2mUMq4*mxE3i7+^ zespVgUp;5@%=Eh1&4qgrZWYWsBg#2!PpO7Vt-T~&Aq?TA4qc-={O_;IRJaS>5PLEj z$$ZuEqeZ-HYen3wgIrQkdACp;RUr%!=H{a=twV#B4n_7>96>#@%O{3y`_4SC60|S- zgG(|s*?!_N#__DT0kAGeC?o62KcdHY#6F3qzh5>Zt|j1ZYT#xVKvXs)@a39Pa@6BI z5&sqwaI=9DiGarQNQx1zYgmbf(DirShQY^q`Jaj}|9<52{Dse=kq6BUvu#7Qfe#R6 z^Ke6lpo2G59fVd@s?HVD9A`$D1*FINB420L#^1Pcd%UD(M>i~hQRt-_9>~GW7=&)* z`U!oX`mlDlqZO_eQTktv?Pn8ue6iV>d)QRXhc#30G>&7<_kDK~Sf(fo72}4MBcT#; z=Q*E}-db-&F*!*v|Kk3*K$@}WE`wVqLqq=aHi)lC+SP#~%c0+$NGrph|d?rSw;5$lV^Y~_wJ7Pa*)+`yL8 z9@r0e6D^A)=6{(J<74e(lrZ)drNWzi(T>ayXPV zcNAX*^g(Zi4wp&R4N0j%>e7@nX?F>nzpb~-;-t^KJieFwTp|W6F#6eaz^D`i1KkN) z3v=T4Bj&w1XFj`NwaUCQkj!(uEL7r{5H_YzH8EHWuuq5ms~pkZ`TdkQY6sr!=T#n^ zzILz26YJ9QOHatloZkqE)b23$0Y42+?{FU0N)h^+wg07xeyfR<|AV4wwt8A##LD~) zjOQ}Ou)BBO&Vl9$E67O#VFjhDOJIZ#vd#xOPECFM+I~`|_jIRkwKnMt>pIIOcNdVe zPrf~c|LYXUNpl{yuqnw#a?-Jm02PBZ!f=M36k?7Cz%h{d=p3yv92x0EQ3aGP2R%FW zv2-3edW%f>>XY=DY-ul+1X|!zlIjHxOzXC|H-)1M4L&sKh+a4;#S@EEF6EP8;U6@Pu4+yLV-8ZJwFKP(+2NS>i6wx!qb}EqD~}PaR$HiKUpDf;f0~M4wQZ<%f8~FQejIh|=gI1?5`cEwIZ%cK;qp?Y?b}iwXu@;w zz7ob!as+Q^JGa={$3LVG9}+R5cR|N&EVKztz@(oLd1}Z$H9qlYSOHeQR~Kz8Aw! z^44Y&`8n!p?-b^yziW#uD=nah1*rFy(YV-;R=1IXm|~|#aRk2o&UtZrRbe?>SU6!_ zZFdG=bbJJ=2XF?tkQ_x%6ncF@Wta_H6LqDoWD9%WXD4nOSUtna_nS55^a+(VRoyt%EpISN88v?;eK$D5;HRjDuE1h@m5 zS)#T-*A=a%TA!x#IIL9T;I;Uwj81Q6$C|urQGd)A-TO#|_t?X~zysrhC>!xKt7p-2 zk6l++FVdF0=pI{o6hq2Iy7c(3zMWg=Lr%WOk>9p&085sCA6-GI{mnvju1cJBXYN(E z@a-@*^B<3wu)1eGW5pwb7M6rYV((!6IGsR&#m`6WmWb}2(R&Yj!=@TTP4Pxd(s(|oK2CLJK1qY~mm>DgA+Q!18{m2_|Df(V#J1xT4dr$09LaLv8p!>xK(|$~wz0^xi z*RVkj;9CT}`{9FjBTPyJ@88BurTp2L8j|#?Vqnt%n|g|InDtd>0M%@VBjm;epx_-z zMHIWE_iP4_-Zy*DjKpxHP!WW-E8bex}BnofvU3KSqQ0LT}BEZ;hJ=Meq1W9a+HxE zrN4_AW|_%i5|OL32)82mh$AuOhF|=-g6fGi`xd^M(K7yB zb)s)>n$O;LhC8geo87kovjjbPk%DsP0`%{*X{T(D8!1zGD51(vmVD-;eVAHMZs_%( zH>37v*k3n*SrUUh2eQte`RL!L^Jgb=;wC2buAE-=INsQu=Po6zj2Q{dLq!bC7%!~} z_RS#Rp(r=CE)*SKU!i#68p5?{7lGew_*Fb-tyl3(SX1k;)(Q_MABjE(0Tf(HP-m>5 z3ohNtu7$cv4=8+Cr(}C@Y@=75^+Qmvm}8D|t&bc1C-2_vf;0L7i&p_SXB7mwqz6)Q|b$p1{0f0mN;rg%l+6OzmCVve=(;e^|7} zzSR~e$tE>pmvTWASHXB(k!ShhdJ4ql(D@XlwZ@KUo^&M%dEKi|4ec-T5rvg?evf^* z=o69p^WLltTbxC5A!t_^^agIofz~QVrd)uQ9Pgbs2%B4z^T>U3g_5Q1x7{Pnq?ypF zp3WiB5><_A5s;IH27IV(9D{j52)wZtL9Vb`EYj9sd&JP+{H!S`~q(8rzC`z||ERTAfeP%Hn=pT;0zeS(`9>Q93F#Z69W80JF&3S9zu z5s=UaDbIp+a!5&>kqxhp9SzFiaapWQQd1aie|=m}_TC8-#vE3hPY@^rmWj082stVn z&-}Wrw9(S3XZY)#gaWPduhh%>WjYHuVrf{PZSpS{gEuHC3FWdVuP#0Xy-ua*W=5gP zW2uk)$=V#gzP3Qm)BL2@>t)1#U=ANd9eYC@TF#QcF)>0g!1U2);ZWUE z48PVii0TH+Zf488`e2nF<^YT>NYV2mYH!#L9Wi3+x0IYJmrB~F`aI&}V9*&1`^N9$7Bd~CZ{1@P`g1<@ zFm>jvzoA;3>4$xmhC!65`@ZOT)Sw-f`G5Yw+W%h;BIRzB3&kwMQ1V7)G@ll8txcJN zSZYfC8b!3yPj}gs^+lalk;C}~@80=N)oAJUb()0i)vL?LeeP%z5~+RfzI)?(=rhXU zR*K{M{n??N#KHFab)#Q_a-SH{^N31D=9)WU=ZS5<;~Lv;*U8KXFJ?1~;HiZH1kEAE z3&VB}=@PSY?KtYp#zS2X3d?>6*LEtB@0eMoKW;=iq~ZYp4&x zHs4>W46-+_6Oa5#d$ube2@b&K9Y0Vc#GDW9u>;Z?%N~~K z*HWZz-@9^b?&Hn-l;GSzsEug#AJAl=iHBXT#KYUFBxjbDA_Ejza_+}q`Hq=^m%|}=SXk)mir$yKNA-DcBi9S`bj{fq z6DsT@dI+7Z|FYa23y9EZS2+WfX8ij>^uh7{@Ef0ES3Cy z5b!7%nk0u#T~$f~*bYERZsavPE~AaI4f*EPsd6_GM$a?&9G9H?)&;xuo>cofZkdW^ z{d(R0W8cZ)=S7Tp-4T76Wsm>kT9Vx9{Wt zoQYC@Yd_KJlvVb!4}R%Me)-qGAV(RuPZw)aVm*H*2D>gRHYP1(_=21u7zNaGXp2C1 z;C8LWG;!5qjW(}{kYg%IrFmgi7NPs}sVTmx2xW=Vtv}ElLgJ9dn*p#M67!L%e#u?3 zQJq#+3VxlwlvE#9HZY*~C9QY*I?3nf+J;>4IcPtMKvn6%XkRmuH>VZD#L-PFifdH& zCUx|e{~_$X!?_IGxN)=0GD}8AvMYO)>{ZApp&~o0A(D~IWRDb*5oMOl%#cl1vSrKO zWYh2T{ocNw=l8tt@%kf29i7L0-Pe6x=lMC;=d?cmWQRX^$%<&KUz>d$PPH_QMMI9K z$6+7ipOBD1Qz)7)~Fa1;uWxUb~P&JIc?IDM9>>HAv_DSX8y>*0r z8N~W`?HI{}&9q%QOZJG-w zna+v)SO}b4{JsznozhO585G?kZv@Q8eXU^S8oSg+ci%4}cF~!9Z?p zM>s}Zi#b@Y<4F|e&nqaVwm`GTL)@JFIN-13zH`gk0pH0Sc+h${)j=7u_+z zv=~-phI1F~2demtJQs?JUz^ZcyngSMWqkQ3IUC4H?++|MUBAyr9Ubh;5vE()f&nZQ zlQzdM<_X!mrY=10!BVve>q~x_@!^>Hd61J8Ij9;6LtJb?12~F)cG~5eiLFvg?>+Iq zE|E93IbEr&&3$PtfaP1z9tPk8rZ^zlI`Xhrq=j}*zceN<#gq-dwI*3bR72kI*tznu z2)_m19o6<`@G<0N_zrx9zd`8l0P7@E6PI_PG#y}UiSQMZB2H&i^JwJWXmW9Lqq3ci z;IacbSs3e#whryUF^1eD&B}BJ|4(Ly^>iexF~`6Ba+R|2R;6-v|e&q-#lhTYNpvEG@BByY}=f`Ho!h<1O zSn(79)3DA!oQMg9YtUq$#$l`-H~XUVw@f}BVX2duS;o;1>)r8Ym64w_aZ~RbIoRh; zvWp(#i%Eph0j;9%ep@x1*Lx9CKet42!e_DMot%U|SYenchlJ!Ckq|1pfR|D`>5$BJ z($}=njW3^svR>CP{moDKdvcs)Wl1qT2lg4rJ`X1J4aNRn$vzM0KT%81MAdW|X9^{Z z(~vZB_`Xjt9JyzET_%c1G2aNMiO#c~;faUz!P3os8*0(vUWhW>T>SLi=(_Z`p{oQ5 z`4mj4RjyiGjGW&92nY%CA@oGaUYM|)Wi%6y$LQ;cFIY2+W)`g9B#hhDTU@Dlt%GeW zKg=CHy6>Lv&uv9rxndZjMGL7HawY^y9{fgwNOWPB3DZo!EPmA(w#Hco?2e;1oZegW z@0P3zm$`)sN{6ZGAFR09+06E_#pimWqQRW5Ip^Qi8gzAy4B{Vtd9F_TF4P@?Lk)3D z1Y!m6U@imwp4^#cK5ls*9#{Uide5bA@+E0xMg8!@dCcL!VLmSkr$t)ypx8XF4+$jV zVWGe-vhM%=h1&91(*3}X$*a>_Lbz==hAXijhNgx0OW(Y;E@-kOLl`i)A+n|waPR`d z4oX75(i%+h9H^cxDw%b?qnB|r3?-FP?EI@rv>x*kz$`ChtYn$4>03f z6vl&$ks!@hGV{TPn3@(`oBQ6=_3!mq!KaHR!tL!6)TgQgC+X@c_=I?N^XH@S6siFQK{eUIq{_Dt3P66&d#4)-b5&8$aL%(*QVRX zJD=J2F%)M`CEoG*bq5q21agHD`#bmtv(Q&M%ser{1v}#w1n(OA8*%I;8ug!*w!KN7 zn93ShNxlVg(0G8`8Mi@A{9NnKJm{VaacNqehhYzAI13)v&9PR9DwO07?f?iRizH zO3cYjRu`g`4Iags(YvI<*(oDA@(pzVG4;W~rqU#x15*Z#WC{80QA z$qk?Fpc9wbQtBp{1#%XCDB0Qqx`%p2BwzfY8}l7f43_D}?8)7J2ix1uja6dB@RKqm zsyf9S`{lcSJ>A$H6$68kE7XUNo50Aiu|1DANwrzHsN^mYQx?|IN_;WwDus~VYCYA& z&(c0GkduW1DD*l#4!ua+!Jo#8gE%3NJlP%zK6iW7XynS$$?mXK}x6nd(?8GT2)u%>E0tH_#^m03WqZKO}|> z-~Ce6W!KXWhuXf6PGRFmZFjwyA2(rf4w>Vec+ucXdIe&UFtA+UU~XLB9q|E;PR%FGcjzJumne8qYyWiFNt!a=HAMQt67jbTs(CqXQHGaO zJX0VCCw-TU0~i$DD1k~dYgwggj%p{fF6<*2XForp;s z*p^5o`g+YudK);bx#^JVB*cEW>BF4yNVQ29XIF%c4$zYJY zR&llR9^fCSxunWGQ*x)|<#X?Lv^k3!q)siC2zARBl@8Yq`Rw{Ugj#xD=%__#Okxkc z8ZMII7i$ybo@1O#YwPa!p3eG}q>epI^Za>SqMNXtQ~~5*%p>B}j3UGUU^la{viygX z?6sAew@gw8-<|w-%sI2AQhTcFy$NfCHWoyt!OjTsqxZ`ViP*y~Pgk5vJ72iH#vJ|o zf_+K%{k`I4X^*%yI|IdJvyWOm*T8HD0FyCVuJkLWpuxe}Rm-6Uf0?72jl}!c7mu~& zB|VvDZ^4%K--;4v4fnu23DYc0V47Sal}em>jpomDdT^LeQciX}sj01Y)V^vJ^RS~^ zlLns|o+ATYA855-IfpsrA%7zcW3Y>DDy4VpnK_e8{RzmTr{A~HI@6Nf<@Hoe7=Y$qr)oiy1IT-+RXk6iyjgga)DipE& zaU=XFzS3sPztj)>-akp+`#)QvJAUWrf+!^f*93sp1;Ga~KQS33JHryUvV`P}qd_(= zv$rKRCFZO@tLJvhDQ=5%+v9RV*QJ0wjkiC>%)ii!Dh?A+zI}t;Wi;NuKu|#|EZ;R% zn}M5`;;F}{n?}>*Kll-O=R~XluZo2-|;~L@kRXIW)Mt1vX0Lz7xErrbF z!m)j82B9kS#VGlPd9SV~a`E>w+Dy*B3%%N?U}1mdLq|GUjCu3r4+<%Tv>8=kmG+rr z(O$1RlBtIMf3hfi~p>7K=#!gmvbHbErumx|Pz z!+A8k#@}aJ^e%z_hdr4-mM!YpZP8OPH(C4wI4x>f?$%_yM z*6Yl45Ets7qf_msy-bYH+VQo8JRIL%i#A0OteGr7RH~yc{x8rM2plP;3j7y+qEFW= z(tO)y{8ECD<8TKnQ6RT<50uV^vTOfp(jQA#{!uzR+^3U12B*zoso2WcuXi z6OCs^&j-_SvL84+tVvc%eK`S{KT(>O@tE`f$FlBpMRxD?9`4UI`XA-;`&x~wDWAz2 zYH+*0uah@E4N#vCc+}DF6?N#=VU2j-p17;BB{iw)OQL_i{d;~BS+7Kw-hxWvxo&(I zu0kX#4M7L=IgT8{)av01mWRHM$v#R+WSqwFbmxs-SJ9bwX2mBA97iY1vD)_QT=xs3 z(ZMFSV$An$1Lh76RlT;{=LQYf=c#ZcgQB8;@kHZYm-qet%<9t!$U%E9!bmtBhe16N zc6XTla^lWbq_KVNim1Mju8)dP_N67raSO9S6QF1wNc9@Y;TjK^OQ`eCeoB5mV@ge`RuA($wkey+w<$mB6*%Q zANw>v)GKt31{RbDsXo=6+Yb^69bB`a@0eq?+wRlQ#d&miIH7v?=XH%-Y3a#8udUhp z^9#p^lj_#nKu%_#X$8H1HJD@7U*~cxv+%e3%}(QCy8>0^8woGIky}nS5_Tv%E&)?2)Tb3=>eJLT|I$C4 zJHdE{?A)|o)5WD+Z#`*`L}RkMYgd%WdFk@tIkE!0$Tf=v!fZtCT;=BE?72G_G@_P7 zoM0YLYfxKWQ#3+;on++ikLO1SAjk>?>IYz|^Kh)i!|d#JtRbr(;v^Tt`=z*IGmOX; zm!4w#gd_5d9RaTNimZVDDh&I$DI3uJ#*}gX^~?w8&R#wL=kzVjoQ6*fKGF%iq7eDv zt@(au?aPT@Z?Oht;I_*{$PayO(>@>_hEh`h8)`sOZmH;1|G%nWkgsL&?+y7AV|`Vb zfjRM>>y!A!$JSklCT&7^-qKJ%+*Yjsf;Ocu~5;o!j=bl`3@u zbAy(PcRNgqca5J#Ce}yR@4JFfEQ&Us(JjZ&Ly^hQMYOPX6z&W_#YIeyl^n}9a>&q$ zipX`m`qODazp92T<5`8+^O1nNjOV*i8w>~k%SnfNY}{*tTm28DKWM(d6Oq35JvLA8 zXW{I^6i?u$Jk-$&K{yX}&nCCf&MxSwtrH(@BE%9dUn==-Bjjfutf#suay%{W*tfdU zAp2tT;{eZqvj7Rkb|cN}AZPOZV)ae^AxqVMp~{bB$^n;SuNeD9O%!NbR5mThYsG*Z zGzcQ$l;0qS?v zPB_Sj-4$Z+y+ILES*X^N-5z;lWk>E-dxy$gdd$hvS8D>fWiY9LPll$Z5mUHik|ZGT znlQ@mH%S(L*^kQVzZ6|^tTu*%Nf~RZ7kECLfd$G!B`w-6y&J@wIJeNh8fkj>Sccde zW2228F#1Gmof^((Vapxd(+y^L91XY=Dwhz2zYH6RR77;y&gZC|ASaMrAbtJ0+P1i{ zfHYPA>O|7{W|_(SklZN>LMU%TxMl`FWAxl?mgv2c6C$jCI!vXiYKp^OdRQbLJ5P3l zWUT7d?Z)l>94nAU@S#si0Fu*%{V&ov%AvtRzc$&`J$1Gri?YC3;8$(OxnRjO0lG2I zGy5q|IZ-~u=?wpgflGJqe<;@Y=>Ju7D&oYl*RMzZ1*(+t&!;D3TE7aZOzatg9C)2b z8_YH|iXhuRnJD&XhUc0%Nf%BeL6fos0oU(%$DRkOP2aLbyh@ebC~yP?Y2LiX*ozs> z&D#4l8jmSUgty;I3Dnwm5K_$IY0MYH{rcH6RI$wtsCu(H$6Yj6a*l=qlw% zp9o>VdwIQc<(b8cwfq#L#MQB?zWYY3ijZu9)_fQjhdReANa_*fn5ks3#JLB**i1xO z;13bu+jucW=rPKOUY4XG5hec#c18rag%CIq=!U+ju#f+e9!UIIj-?KG|z*U#xMzwZ& zkdpx_8MGoyFT!XP#}jw_K3hoD$xLsw^;F&LJ(t%l#AM9Q^(e~wEL&U6ACQxSoF4i( zcY~XOXt4VF;~ow=YVFd;tZv|q5%=x{in&L~8;5@>_2}r9cZW!`w15yqvrzl#JB8t{ zc{MKE6s}78#7!iRZrbgEfFN510f$UtZ+z>Bw}YFv3g~ME0VIR(fl%4PcK)EaaOPKF zx@>B0ylocNr={x&tFCdtx1;g&__2)DeO@kE2x%bQpX(EtW9h4O)=m;{EO5fix99V8 z=R4sp`O|3^C_{%Wx1JZ~x?KU703Gm%*IWogJO%L}jU0Zovd+peB+@yiRlWw#587XvU%oHAc z&ea6gKY3n0K7<0-x@)k3%g`qYTv>0{5Vl=gzGdW-)VOsX9=At zB1lYeBnSiRUa$J*dOygC^BP^hYiZV5bvm?=+sOBWvc*kA(SMEIbD~IuLs~or5{f&O^VK+jpz? zsBe-_)cn(r92@wXIF|m+VaXj-W|M#QQp`$Hf7d_}3cGo9)Oo|8=aU5$6P$ByHPG+$JIe)|^&);M*>-jLI5aE)PvACef!^TfnnhoP}= z-9nvQo!@OGS2!aUqRtf7{s3>b2tYOPI73-DY85F+-2|L|vW%oJR4ep~pZ*Yvk7?ECYDha? z_roGS#a+Qf>L?-}jk-F_ipbmaetNnu7YcmTLOUK~P7i-Mt zcSRKS6jrQRByMj0T76!_C%nE+gF)j z>(G#)qlS#=6s(p^3cb>Uq!}8jB%ylq&0Yqi%D2e%J-Pe5`J3+%Vz&u%HDY}sH@{-1 zOW)$|D<5p{33`QN3NBZt?wh3_Ul_)iL5159Gt6IK@LD1V$#1OL$To!Zt`_HO4~f)63YGX z?IeDeu^C6N_Cmp93FqTaP75&PaDbdNw3?zX(?=vE1kZa#q9Ndv#OuxHbGEG?+jwAY zcg1hOS1M~Vg;w3s)4c%r1E8X=!>>UvtL!V?dHskd@ zafxTHId^Vl0~Qd2B4+gQS%l0AVw->X*IzuBmaG#oZahGcbr1WmgggB+x9K=+dWV!d z{md>9N)n+NSwj~i!+SlExN66DWBzAekFrPTt&jPq=xa*pcaIP_#f>+;*EH4y3?K~z zcj*21%)ls@*65makzbWTfl8EogmdG&N6yt(#fS~BR2nh72o|~lA;bMdEm8$n`Umq~ zrV}IHeO?RGxZTPgB*8MPM@`Fa7X-hp7plCHRZo?6cOOOb1BE+kKiao2wktbpICq>J zC#$OY+NAQzNfCuInv-RQl261nRbHE2--HA&)cgC!jHp17@;PXtCh4$gE@xlgiX zTz~7gjEW|~o2L&Z>T~-Rye@;B4BvsT6a_X9F($pHQi3IEi#H0&pMAf{-DIh9eYXAL z@S^@O`|X~xv$n}_?V+m@DWc7To^nKPwSwfO&~iYBbybBA=@*GRq`DNP*Cdpa6)FvO z6$I>oBob8C0fvT2s|RxP+NE?8C(XMEKT|h8r8>VpS$s3J;G_-P)F@q$iQxz&Vjx>| zFq_Z)usmyR>q6PaO5`bhS0DU0;S0uhLf4fN2i*y;-45T2UP?>>IXQj-gm8QTLOcjW zwY!h6>3ZHz$ks8PZP0_4S$!h+V#USZTvve~PL5_Z4&xfnW7P|r$J=B)nHYZMbZL%L zo!KVT^F~xmPQ@dy@YB@LQU?Al6xyIZ_Y_dqBHQ@u;h6YI0rypDn!9^N0}&MM+P04_ z=ubV%dA6f=p(PDk4MfBsCyqWQ?u!_kL7uaIwOh!})5ygxid0?GKuVKnc-DXXSFq`m zgnyzpl>x%RY-faXq_Gq8JZ3I4YI>=eyISO>j`SJ@PxB(f6fWD}@>yL|S;%P32mv{u zJ4AY)f6rr{w{(Tfa#B-mHs%QbQ3i&F7z5_YZSK0p_UpKbzr+Gvpod2kdX12E{zCF7 zpcdW*;n$92*y=FO-M=02YP*05-)2zfPHvd7^sl}>i*)?%b9Ja;&mbo#c+h?8ci19Xx%8GcM=mXtdgm6Y z10DO-Z*{sjJj;UraPGe0!;{p2NEyt^hJr5Ccc?>(kzt(+XU5})Dq3vk*iGuB#^1%6 zs?o6ImY+2%_m(v6wT^(upN2YoHecQM0En zHb#Wy6SneH zp*;A`ftelRB5W5e!-MZj)QlPR^)Q^4Ex7vS?4SVm*U0=e2pP&kpb;?}rH50|v;XbT z$_8cRhUA#0a&5`6%X(gR&bDLZG*>I_&?oD+1v#ijMI!ZX$bEzTD@o+z(P@xtQ)|H1 zezr$$*h_VWcd6#i!?0UJ414cygBg|u5?!Per2H4=JO2%$ThckN-q8a&IiOBPyD+)X>5J^218xMp+IQJ}`jYc1G?c^Z#T(P^Z*gOC zM%$N8?rLRXQ{c!6(Y)Qp?1x0OhX1qiaM1^uYC)Z^#)s4wIhO|NgGX!c&f(gjG56E?G|8~hQ?d)Mvp*j%40>ACdSYFm*)w3_tkb-#R?)>$luvNL(2|6- zjP0BICx+?C*}c0b#$2>SBHuQz^kld&+v;(~GMyJr3>}Be1q=k>L+ZrVVK~;l-hzG1 z6#IDIdrp{=*m-P-R9EJ*NIxsd>&W!=)cNN2;w##7Ah%zxhjv*@nlNT@JzAO7zeM{u z#~A)lnq+Q_8X=>?h=M?^VdzW#`Inh*Kn{oskvh$sFpL>Cw<5aLy{aU|=cbj|z^qgn zCZl}ZA;LezGqDsqe`^-dDdc}ekP4W%JoI;i_mfFUvb3H0xBFT~>E?a6dTgV*sEr@T zuFcR^U@;yol^X*&d8p1suhR?31i||`mOJ72?*;9R{ z{<>=+?n=bX{z@-`hRn=tO4? z;Wt`*uy9^-(T0mB8IQf?BFeY>`(%bztUU3u&-|i8{c?ZUwIcI5{6gKIQ~g~Q=J zur1xj=P^rhHC$3EJnXE}WB~P14u*xGSGC4~F2Ncj=CKAbS8%L-3r#-$A`($2yt(-= zv@|NnK#XX`+E|B`v{#_Gw)l!apgn03=;=be?5;l&YlTI-p%;r6KT-+j=fr#+auy34f4z$akQ~bj+F8mtFj@IIi3mzSMfj|5;d4XY<#1 z3#C#w5nD4;XCSKNrAcXHL_61*pzgum{P%Cv<3~}S*IerA)NIp>&$3v_l*;^0zuzn^ zs_6B%@SVgBoY%5W**^HZ7p-omDAEmJ+h$9M$tD>T?Tz>SG06Hjc`}dVH{~0Ko8Uh| z^EeXIckjReo>4aCJ8KRSLS<)cRHPTp-4*@VA9???ddt?ze6h~m84T?{1q*T^`wk7o zMK^|HrRn1#_vBX|Oz1VzA3-G3_-~n))$|FNF(4jm;^d7sR zUJ@NaFt=UyZgKtD>-h7zG|$YnTQjFDt)4jE`u(QJN@DF=Dc(WC;G(I9m^nR3S*eMF zZa{JA>nq;nZc4_dl@~K~($m?4eV`|RR~Vt>sF}tnIcH&|6T07L`wE&b{2t31Bbgy1 zT(;Kyrl|i0$85S=3&>7k$_kY6piV<`$8jQdIKroy{`;H!|2`RN^=L{C^W5f)k#@ZH z&E2_8O~X!pjU}5Gv&1gj7Dqf%RNc&eQYw z{H)}<=RZ8q(ZF|e!0noS7zblxcQ+#<|6X=wfM%sQS&Hc(l(qgsINzQ z_e)1G=Zk=xXS~c{B=$`&$*JF$?E?2C^vqAPXJtr6kjHJ8jQN5bR6-zr<)_H3TlUv3zAxzashg*ueD%!11R*Gg^iL6gHvEnKY{!T0b<3?VMgT(ydv9 zq%R7$+#@)jb$LZ)2>dkAi3cg?d8Ca7)+fOgZIImmxVa)sJu$5Du3ilL8}^ISrnn^C zej0Ye*Cap=dSa1MnfO>t+@WJ5YF%;TzL6mtIgS9Q47R#!qUht}Tq{3lYux^cC{TkO zG|M3cP??b!!}a99vi+9y%8+seI|Ta ziDyWKDrd@&#Pm3QeB#}oB#B1g;6c+3c*>|l8iVlGf_}};Y3;{aaJ7 zlCpm)WbOXJsyOpczuN8}$idx2DDaAa+zNTG+nN(Tw{Ml-X};r7x0P3TQL%Q_`mIpL z?3Dmh>JM1fjF5Zar3u-^d}rz^`Dv+n{(kfNU@VH0N3W`0AtJlGb+eiKo?ktam;l&q z7_f4{$s*`54;!qMUztq*$VcI-H(q`|9_jD5OvI&FFlXte!B#KT?+J1+gcsrDXx_m9z;;3BbmK=ImK|yDVv zd!mzaE~DF;`W6i!C(9>@a1D3_VD5FNox67l)9Ik_b$yB~+a@j^*=0kmAPd6yYJb9& zG`D?+9)LJfnzI6f$`FS>|LT&KZ{222eG%7JRW&(*7Bb1JN!S9b&c|)W7$#dIKu#Lw z{h`nCE=*-bzW2yIyx#l$J3MVtzppdnx6wQr@vYDM6M^5Ko}6ZaC7?oqBPva^Fo^ly z4E(Ixmn%28a6NuwH+j})IA2QH8@|f_-2X=9?m}Zl9XRB2q6b_9AyJt4%MIrs>?;Cl z0`zyQ;&q2^@}5sRyNJg`)2yJcb>*1S^DvMDDmlbfL?A(SILGOF)ZcKJt;&VpCUNxr zr8Tg_HR1C}tv!RQwLdgO8BwfZTEALNnR?!Idk1BHp|R=qNj zj}k`K>Y#xIY{Ee!%FJQk+18F;@WcsAM;~(>ne8a;wy7h6%M=|aH=O3rIv#Tw-T*ma zh;X3S*?m|z?KOiX@lBOzkfmu!79jifqv9Tu0({pqCB1H{Leq+*Oncol$zn zLG?oMt6pr>QcPd;eKKRq-|;gb2b1Oyx%>vq^ZfrR`QE$Rb659ehgw@QeqE&)?zQ4c zazCABom{=l$|-PQp}7%B;)El8gYdi?Uz%2SHHU@Cx@HH*V>fr-y5Dp>o`6L?+@z)6 z&L0KIA6b}=f!Mcfq!tLy3-28E_nvK;pO?gCvI;vZN0LfqN^gSX+E4PVgu+y-c`hOZzMfRXN1pWMzOW2CY_hKVsq{3#O|ltk-&6 z^Kl6WD!uxrPq+nyIDL9Q%sFkd$eZLM27Wy+&9_{P+2Q>*JI~wC^1Q`0kC943y|o}g zV~ zmsykQXjl_RK@OA`5?72_$9(S8=KE>od*KU4`J=Qs0P@uZ-d+#HT?so@a zklXK(M_;?x!+8$860-zi@ASUT4%{XfV}1Ls^YM{wd`p|!EZdt=3M;bv&x1J-h<`rj zj=2U7)E*{|*RUA_xr{{hZ_C|(d+cOIz2wV?^}r0Xu--{hkb^!oBpRo3Q z8?Lp=D90zR3D~|?C~xGK^l&U#3RLPFUR95()`;Q?+u;7<{QXAFcQC}>CR*<7Ye*G z6YVkPs1`Y{qtHnf@a$1NFS`g?6sZ#}fH?x{K?S-E1 zRXQw-@-PDJ*HJGopUH=)ubdpL9(~GvN0CXm%>N6JG5>->%InAWk@CIHt(zV>9Gkl~ z-5XYcpGkZd^v{nf>W)4elMFNel4EkP_>4j)M-r9$T%}@ zXW?iap#tQ}D<*V6J`A21QU!CneMqS>=(h1G`6+wly0ZzTYcKzqc!V{D(p%EUWxjZY zGzTH3an2uOvU0wWZebJT?)C-=&EKSDs&u^@Vw3s92e0l+j~T_~sw{wpf}okvp8X_p zci@FoHrP)pbef>6E za#CT;2DllJ%S>M@Z^7b1e^5aor zL*ni(>x5z==ejIhjS47w1n`fUjHTb0U{LH{# zljYcee6t|%pCGzxydATj!mT&GMn5o>YMCrF#avG4h^p|v66r?(u-rP6&*;dyXdt4gDBLC|kQdnD78X zr_3JeunhCuk=r7o!J0Y3s6xGr{Zv+dY*B99yPdLw?cILrX1_ca1>IIYV{)}uKF^5g z;jHnEvW$DtoHZ;ey?HKm@?I8uMAGS8`=_r0K~5e*erUN6r1~4y=`bLEtu#ru(c$$d z4Y9eNK0kHMX^NO^nsH8w8-{mYK^*~*sX-SM>UkM`7*`@OLs#qQpfWjGQu&Y0d#{3< z!dn`gjeTnMEq`5Qr1ZN6IUgaKuwQfswj-(Mr}+_bK3f6-S6>pL1nO&r0p}OALb|PO zar~+h9324a0c{)7;}iG;V{?*P-l)jEZPaByM;vR7BOB+o@aAmyEzT4N;^Zh_eggrJ zgVs+3f=%aObUL+=wz%vGB^(o<(Kqh86c3{+`Nbd~nV@tdbNr7?+ z)rLmE>jz!RrK+FDBg{SwI*Gp<2rO9UI1O_0e9#<(+DE^`E(We3JT3p>t`|$(BIRYu zF~K-2h9YZ2X>}@%wh9-%7Cr+x1+jzSwEc&pxGr~+?)=Sa_gyn>D;D5ywG968zUWbc zAi5LC*t;tDT>xC zg5(B{XZ9g2ANV3DxsRKedsjFoPgfl7ou@B5n>)l&Tz}R~*8W!3Dwlr%>ssrXOJf`h<`Mzysam+3h?9WJdk%&8BrP zA0OlpxVj>eoA;UE-Mi-mf@#nUC=1P|NF1sQsAv%%=F;91ft|JD$!j~CV$aK}n6A(7 z>b%g+<0W~qS^e!bQyA1&i_j!wqT4$_(awe!nf}NulwsMrK~_TXu#o)QgL$@eXX?r^ zp-XFzC{*D&FdH55vBnOkCSU&brj>>-&_X%&^!-%|L#C)_LyzxX@u+;fAZzQ3Gk+P3 zKXf@FiZ&N%K7;4|<{gr_=WBnivw7AgQR~4I=i*1?*Vf~xYpi5S!%xKlv6wsz8bp#S ztB2sm_#|Vs=W#k0N8%FamT5Us?FD80&-(T_XU|>N7=PdmA5I>o?jSLPws7FGaI$ueQ{N@1f6ZxyP`>fVvbh|wR*EX&s{wbuk%jfIrl zg|tNfKC*u|_x?!)&iuhSzfZuZ{VTlstaUldp8h|}B|vVnXuIz7dk~>iSqy!}DsA9zr== z%GH?1DVBxHGA!DWGxFrEv5AJ{s9Cx3!w;Z0ptu&2x2W?vhU8A*^W1f)k4_V!_N~1` z)$0^#*d4nZM3HvZz4Fb7)LV_v%loMZ@K6vJW#jPv*B6tOue@*LAq|sFwNXD!%bdn- zz->yRK5}ZYmGYv~-hK&*AfP(b^Xd`eDtKPOeaSazNi1>JM(Hn8WN%~-o*rFJPd{q3 zhCA5(sN4~bIlnxlw9#SHZ?PD=bm4h6tpUTo>7U&`LF_eGT z%?3FjMncL--!x(LcYA>v!Dox33YQwDo+^j(Hy#n%&|?@kxF+JqaPG-RKM%0;(EWi_ zSj8cX((oNT^*TlcrpM-693pSHO;#-6XWs2NP5hcJO;b@h{#HKJhY0|AFA^H-{)2g5 zz4qu4ofTs9fIFG7X0e2KR`iYrJz8ZJk^g}^d9jrr^soS|6KM;`kHDN4KjDYQlU&Cv z=fAjYWEA+Zkm)zFp0@JK$O(SiTa|o`0PH+Wm_oX{qG!lZ`UciX-M>Vsrrpp+bV(>r++>NX3e7YZLAA92Iw zZuX{)49=2#yWVfOcj{*rPz1>wOzY_P#OVFErUREdTcjDR+*G3iOQ`Jb2L-h)D}*mh z&FL(epLDqa_y9HrDG!~^z=UX?Dh?{$x`g{+{yy6*8@`Z5Ij<#I{P^2HK3+#^$lE>O zTnmGpK}xZ_4?`Jt-6N6E3{E7+hht)=hW>K9cCa%vpPp1qP1t$>G(fmmi z{AUl&j3}`1BjvW)2#*^avu^V`vyxMsS+-ha$4#Y}R$s_PYjzpmGr2(PHTiUF3d&dk zCWs+wY43142*JtMHAj1oT2AXmIz8){RrLL=`OneQa3p&`pqoncdli^_pfg0^Yit&# zxvaUtR0LgCDzQnC#;6>6U2)t8v zlBOmx$ql_auVW*=z*(){=d7Uiac5w&HVVu=FHGb^fA;mmV*Fkk_30S%3)oKtb^QFsh@gJ z|M*4pQ@IYG#CdC=!bW$D=kkW&B>4768P`wCO3&>(iARlc6fSe0p< zg6MMJNA_Pmw$txt%0C>PtDLJjnF!!S2nrm~sB)$eef!{fQ?Iah)IS_ay7EZewQobR zWFqO)2ke`38^1{(QU`uN^9|%cCm~*LNEl{czNv_;YIqW`zZHl5zcvXTnIXH&y zTgjiH^AA5f*a6=jSThj@hT<&DZ5K8@GGj`#D{(|=Goj!T+lT6*A?mxS9NddZCLyvj zrci$?rvNR@=zVzwbIcH>`#6^opSMlcr3XLgRD+&ZUR}=UL%U0{T}C2f4(dy!F%SuX zT5II>4(EvNZWdKm?2VUkiu5K7@fjB+oV?bu-WmF6{FiBE(Zy_V9_4{S2Qdx@W02vt z@70yy3;zi0ji?KVeUo^XCp(;8+ThsQ)=6!9ig}}WSf+xgD9m_8eZKj(NPz=3mJF5` z77mk}D48iX<<$*#`1*k;wJ?69tojKQLtVf}OM*ceXEZKQC zKkLQ(8C>lA6z<@MCS`_&NbIg_F-08z=RS)!bl#}Kov}I$d+S=HZqt`@#&SG2p#lY5 z*aPOLUZ86@HIQ3+ zoQMUItf!a`A}#+}@4WwSsFjzZSN>T2bBh+Yn9&C^wg86Lw{G1(QS9}${?8JF*&GiW zAEvt}ZB8XtE^sf&gGPU2L46?BO!Eiv^om0jcF7&T&O57O`!@#^Cffeg9oEwIyi}wj z&)lF4rB4gEE9fCoV&4{@ao&pD#*^Ch1Vt^RBou&k9qID+NJiS>4rU%;ik=VN1pWIz z*I(F@c&k$~X^16E{3nioka5XOti)-vC6-=~z%2hw^yoUc8Arz5Blu=3xEyJ|H}O0( zG;!f}S$uYO-CO_5l>}>{6Sc5@m_dicRg$vMHv{BoHif^$M5#7SeBqwHgIC_kHJ4!G zFtG6bL{)SrrSJeJn1X$FNEggwA5#8cR zc74O*^{bCuRrul5V|RKoXDc6!LLYTan7r7> z!jFRC*;gcJjptKWM8&C=F4Q*-& zu8n;~M#Kas=Oj8G|34XS)Vhn%>uyj!eqlm0T*NYli1SbNy=xAlGc5)aF%IQ_{KL%? zRt`>X`iVRCvsRntBWZE*PfYtU@oF8Uihxq@Af~(9iEdwnn?kEu zwn!-}JF_x1HRe;^<1ePe!yS{=QK3FiSHGS7{wdJJivpuE>c&Q{A;CuUvax_I>wkYx zYyXT|yXBv_?}Ay!#O5jrcB;BuPG553DKS;P#6qV*OLa3E_`(n^l}~NE5l6j!g*TbG zhx#&Gqs^52*6wqzGw;4^_IBr%&r=Wz!1xxla*KDz(2Cv1>ZWW;UFu&jyQMy>bf48g zOpVWYUeToWpJ~MDT=q$TGSJV4*7-5Nkt+X#r86NbM=cj!z+pLWaE*W}Fej+vDC<(G zn4XJg9wnu(g?T?i-tSZo^Xms&-SK#BbUS&gqqO!xAT?;%Gw(Q*cA4O{C!Epmp2gH#|O~9B+ z<*eEc&HEep-+y1=^y1cWZjrR5ct=3@oBereeF$lX^}eGh05Lbz^1mat1TMC!;)C__ zRQXqWmvNHU91@sw7jEBq*?6XxwU#Z{rY+S9QLF#$AQqfTp4T)*-;^H&Y67pWt8~0RQ}5j6?L2*1X)Uka|edaCJ=hEi0>&ngvrk*~-0owf7&H8q73JEeh^0=h?QG>+c6l z`3`yjRt|^1{>i-2FsWU&vi<3s*$vq=nwtyh8=Jf>1ZO8!ZY_EDSA!g!2E?%`IxOb& zUM`nU6$`Y|`#hx};n?!@h-pD5uual*4_aA+H}=KCBjW zL!XiMt98%UlP{ybYOyz7IS;k85LP&7`3UX8AQt*Md;_|-%9K%$(prz}=CYL!UoRov zlvJra-Z6gCFA4l$QC?v|1PXY4#aQ5`BQ7dmQ@xJNJ6yddO)pee{_;DGkuKC*DO7`B>wMin;0|R*1+8br&Y4RFxOw_?j#1}4@(jOz=gau z)TE$}=MSW%1+LBSISp&BA3BTuk{r9eyZmi02i@MjmpnbHeZg@2*1`xm$N^;(l2c4M ztj%|}%=wtdn!i}llp7qz=uD@(Q+cdL`sb||Mr7p0LGpBFhbvv0 zQj+9ns@1Qizs6x9J@R6wM36888~X4vu-J3in)O9NX2l9R02#^lh%Tp!#R4Mr2!i@*Nd%kFUBd3*a#x?RDxuWhYA!84t$ zkKivrh7j#$bktx9BV=BU4F-K_%8k+OYtU;R5NJr`P^IRNn-&lQ+r`4XKlz)N=0gwD zfhxVh>6Y0?g+nOzpsIINOMOi0n!s(s+M7=wOE2u6+EJQ?L@)i=uEiL416t~q_q5kLXN$RUxB+WhKK^d*3gojt8TT26-3*l^;5)GrFZ1w9gp zGbd;7tc>#o<$n8j3P71Ws4%2ItM$-}T@E|*RiV&j{Z1$LbJ8+<5&P*%moblEi8pt) zc%I!$gCaX9Xg&yf1S7oG@I366?W~E&8w9(wq6|d1rH*gugyvWAYkv$so9ynMv$+W% zidP7RE27rv4vlXpP6TWz3TTTY1O)C5lfd6&NntVJU=g@M<(&ssBm!d7PzK$qLxLl( z>&$20GNbQpR=4Q}3xAZpDe?Wl?&BrRa$6GvqPUu08p~b!BYnC#vsYzHYb9sC&vjLY zM3>X!Pk(xNWfAC7AYwy6Z2V#HY%eJ8f^^Rf!v{7aJ2?*VSJPJW+QxLKTs22@%Ac(l zf@Ou?>H}7S&BEhEQ~;ugQSb?ECsFng&2(wCIQSe-G_gaq0@C|vB@3+599yVE~Zwsy)TW9!w>n_0u#Q{wX$UM=VucTsIVS8fL zBUECNCpp;3NBk`fkD-7i$$B?N*9=rLq`r`@v$75hM4h3J;ZF9y?_~G%vs#!pkL1#f z7OUQP$hANB@OKMzJ#j%!4rWN90n_(A1Teu__^%(-7NdO{tMg|@+YHW{br*JNUe0`A zvSMbWV(NHa)XiB`_1*7j%sl%Od|k4q88&}8kyAvyi*4*&oT2=~|M-|=8$;sFC+Fzk z+6nIy6r)X6x*tY&k%uPJIStMkKf5>KQ8j)-HQ0gg!ua%!1rcouddA!t2zDq4L!TU4 zSH8X0$S}y$MzabQA{pcy;RuXdet*Dli+_z6f{yA&tZj9Yl0(#{MwHUw1M&1$;AKdu^U6VADSF%E4owaADyM_#yHD#5PM_y4EQnCKAUri8F3-S8( zfc)QnDjrf;2O-JB6r?)i<9ovwwOB8~c#oUc>3x&q-5kG$yUe*d{d5}S_#vi@ zHl+b?FgNgoFOdSpdN9@0l|QOYFL249 zx1Cx@i)pAO;WCv?nu*~UYltnrO|u=w5Y(lu+_KUO!6`mDi14D{FY6=5w(W|JxPC2T zVov>Q=XgU#*Xl{bBwuY{;0n9YrH}_lUKj%r2C%ZDm1|oL1_?<`{)~LQbNkzIF)iBH z-BY$3`S)H1MiA#c;uH)$fps53ef!1fh}=*lMvmgnmeZz=Ot~LP%GXif#IqVEM<405 zXpoFVN3n0ejs{>U0OMzo&}rlcjL~WM>Fv$%C*?VR`9%L4B7IwB_0T3_iiDriQoO|~ z*2~cS2a){)#WVtg?~n}A>FxR;!M?Yl@w}Nh8G!>FSx==yEAAAYOvFvjq+Tp00y)S8 zA)lc?6LU*fH0`O_|J`H`ANZ$MWpR3h^XdH3yFjBMXZPa_?63bpU`-HuM3Fj|xD?F$ z30ylL=xCHyklZqXH4x&kBPJU1>QRr!Vdps@uo( z_KB|L3!@h-$Ymy6r!Sal!aAW<8i>G9#&Pj*&|&dbyWaGcRnFUN7r`muZx~QbWZP3} zlry(2@rdfpv!=ii5}}!_$4smV^lh9^>KA7O79R^=8g zjM7~q-AD*3NJ)rvsDuKdQi`Am(j_4x-Q6M5(jlp|(kY$Nh=fQ=Biy;xde>r~^L_VT zekglCj^`b7%rQp?$Z*4Er9xFw!T(UoHdK~J_=<>v-4(yuN@tDQ3zAriVxIRN^1r3g zyds6In*-p09}E>O*ZxJ_o3@I0f3?Z`;#tNEJkgRz|2Y1hUgi!?D{VXzUQ?)x5rL}_ z(AE#9M>fc)K?z_y7Sm$JM5pH;Kfb7m&A<{IjIA!lLwKN$NREUKIihxv6^d``Od1NB*R<1L#-j>Pjk^rj zh!0X8vk!|i#-4frI62TWj^N|t9+dpKVY<*kYPkN#n(<T+Qd@riw@r=%UkBfP|w)SOBI8Vre@dPkDx22@ksU*I0$+H7E zP;3s(SM;4gosXbrT9ZP0Rfa#;dDb2cf4wjEUGW!IuEPgxf^&iIjmF?Hd}PLT>3mYy zoYVZ^lc~!hq7+^kALukTUB=2|{7D~V^@ZFfU)#F_GUj08Gnh{dr{{bXG4h@I2r?RT z=)U0Qv2`Ez*1!KyK@aOKC9w&!_r~em5Y-*fm8u{^Q(2E1o^XM4aqshOIekspqU=7B zw|SzelCPBofd|^f(N%+ir~J3IX&HP)19n5mA6~6g>>3$ir2MU{1uN#S(9~$@siwBkk9a) zw_0`i(|v|7^nX+~UAr*-%NN)S9-b9+&kr{Cth=4TqHCas8S#Ampjv+5`#i9l_PdSc zZd)jorZcuDqJkC6MMCx_!%QLhZ09-sr#T=lfIklTb~Aot1T?^RAazIkALcC_UqtZI zoX2)F{V8vvtLL}+>(B4&5Yul=3$1#dI3+y3)wWBli^R7*aN6VpyX&~#rav}6nRD<{ z!Vhy}Gj|H4PQ^;>pH2J1)SobDB7k2{!XK11L1k0ZVKRRFo77FYf$zTD(yj08A)yM_xb;WqmS@3 z&GWJU-Kk4UegC(1hvfnHG+{Gw!(8js?WgxDoEXRUW00ix_5Fj3LH)X9(PqzSiF4;T zva_mQ`yqqI!=vhxyWCs*FisH!BO~FQ5(F&`2LdPZeWuvpV!)aVL-6%4)9beq4=wB5 z4Mb~x#Nw!C5*oomY2ZmfhEiAy3BuEqhR{Z#{2$)7klYsjI8JFdI7*i;E~AiRNkq;+ z@&$7|k=3?B-F_Q2&!&gMeQpqkWzcGQeAN8<*B*?%-g(E*jLLQ2n>sghqW=I(8SK}B zc7L9NJ{O4KmuXkM_%tlZu7D3z5_2fj2Az#*`r5@N^d$ z0X1M2l5;MB;SNU^QE_dN!P6ymsrstg<4_LFCJh6+#}{wYTJ)md)OxO@>%E?VB=GEN zg3VDcvxY!Hfvw?WjIAD*xa8EQgW3b^nBR?$h%UiI04TXeNU)mon#Ave1fn(^Toq?q z!iD{KysoBeS9eNjXY0OI3+U$dUjyw?@}Tqva$Fh;NeMUrx(xqAaJU1E|MLS!9dl{N;e6)4?mwQcng9Vl`1Z~cUXVE`Tg28NeC0*XV zAY)3|`l`hIBU&c&qA`)QX`z6Jsx%RknKpQqieM=i!Y^q2jItllFIR*(Npv%BD7>8N zsre>uejqVlJ?61Z(3>}bZp8;`6~O8|P(1*D&SB9|>dYO9Eb8y`{{u(91TGRS)lb_7 zGr_2<$L5b)!mKyGvQepGv4$23LZa?5@q-P4A;0bVj$?l-=3Dl&eEu_NJN};ly5$k?w?XbRH#A5!(TZLud2#d%=ZyVjH4@=J9~(w{ z?4(|%w*QeKbCjXjv;7dNN?B5|v$?`aUZVFib`~%;=y8G$TCz=wVC?_fYXk!m{v%PW9*CX>ZS)ZclrY=YD-RO{6rjv{o=&d6Hd>(ei00xpNDNz$U)nc{NV576AzYYVn{PQZT4_fa{%eHTfSJLs3pR@`&eX_0^d=LrC1^ zdf%uySt_p&xtfvW`&zVvE>*@KqHTFcNaQ1k>Aum4h&pYF{iHS*;dZ~$Vv;50=ivS$ zGd^Oj^w(`zxZ(y_0SZTc_B^+trda1M>8<3bjeWW#{%mTN>7@=gKVL!?>#P11Lyb2e zJOz@vAjb!Xi;jb$$uOn)-*_w>VT1*1y|YiGn6Ij!AsilIugvcHMf$lPTRg*C%nM@Z z&cO#|NQC`Y!wVD@7GFNvHVHjjPj+0ib))zqGp)HpG4@ivY*QEJAi$=J!9QFIB}V{P zgkJl$JYm#Zwy*HW(27%!Q`8ePW~E*(Rq(YGI9YAfcwF63E$A^+2ELiFPLFE6T z^WnH7l)UvxQu@qH%eJ_;w%fqd&OknrNNVQ65jwieyg$trHiAgppD^aHHhnl49U{=Z zcz0_jIwmnwGtJ34Eyv_!Jofl?Bg}Uf=7TshbRNYiKb_F9i#v0?mlo7WIs(`J#^8K) zclh&`A=q;K$g9i%41Z9R2P51N9Jaj*DS4Lv;O_pP-;uw<4}dVit+9LZIIgy}SmKIq zggEaX&qnE8jghB#QkNULxAs0%9)1AeWsOXq`c#;+ns8qZr)o%({m$2MFz+W=dZkpp zRb~AO%=rc8AQ-g)Cw}@oD!8)Fl`P(rjHNDoViQT7$ast%rpl^OT$8_;HgzYMKyVtE z;9&L^w9Fv0gc#vm{tt5hkNj1JB))5guQ(P zFW=clqR&z4^gwQ`b!R21q{Ek?^qo(M%$BBz_B%>k#x|bQvQU^|3Jh9=C@;xEg_<`r zzTL<%rf@vSZyy>{%)ArJQT}!6<1oiGjZWJt>zCJn{tBR94D!|{p(QNRNJ69j{-19b zet=9;SoMZ=2G&&nuNu4={O>kGSe)|=?@MK?NFz5qey7knNx3~hGEf%zY8rn4^Ui2p z{RdNqsC~`fZFVWO=BBvLz5zQA2teHZVvNdgXnEs7~GLw3Q?ysZx?VRtYZ#eBTJq%{{(RR`w+)nl<(9nAndr zFp*DK6dE`X4>sgLj>B)v1x?m&yddKspQO*WQsa(dG2WPtsTQdxc(0;d(19%o+u03y z#cR+KH$Xmbo~|Fo6d8GC-V_2+x1QG0>9`*H%ADT1SN?MTW4WypfCC{h$TJLtiar1w z#~NG93xXld`3j=(Rms&W0>A%yM!q5HPoEr~lvgn%0dSzr2dbKj0;vEPo&fI8-&5Z< z?X7()QrR0{79UZ~-fA`RE4WH`dGEPJ0O61xfKvde4us7bJcsf`lYfe|IT2pU7~Ema z@87B~rcm*JO(GWcT2FGPO{JA<4e*~J=$b7}M&gq?CqhG%M9c zKUI38f873z!7X~|X(sLly4GZ90)HX~2Y_dq-^;`+8en5G|6W~AgHkf}-Dq!^=eYhI z-=Jd>p&UL?4F)DggIR^}XIcs60KmD3NH8p!`N&!H!uI~Q;JkOlkS+RbQ1#5+#n4l% z_wYN2LBrO^LfsO9&}{jcQ7ZJa4?+sg~wwO_fG1ABn@k`V(VKHzkznMDonuAx*06Es}T%CENE zO5>EU{Lp}zT0=%Q+#tek%A)yPa10y*^&>1f5K_?zpCfi0h&4K?Zl)qp!73u)A% zT-4W?u0?uYtT5NQx>+2Md=wBftf8OD!fu!EQ!wm6FFLCO@|!}S{~V!}ra+Mh^vbm` zCm5<&2-&b(E!1;F8DE{K%564pmZRlzc1qmDN(WjHwBv&<0`OZ1oI@#*PER$N-j2|z zA#XypA6k3&*s6YIkRM;p zEL+YgdO0-ulLADRK`{%Ik*Pl4n?`wGoUgz__vr$@bD3O#;wUO9Mc-LN}q zJP29M*hSOUrqBwLblO+nzlC!SjitjkyqJ= z?FZzQ?!&&@*enA+H`iRf(64<#Ujj-T2nWdHbqD+PAn7&P5Ow-(FvTfzO)o;K@3iva z^B~L&T20#^{-YZGkyJ2WQjwo#)f-gLA3g=>>G%UIN(zMJdrCnE8oGZY=44g|5 z>?wrs3k4P)+;JfzKx4r|V+ka}KqJFvWk>VQ!NR+ZP~BuWKy&}cO0qd~CfPdN4#{GR zyf1!IV%RRSzstHhn<~*=Y~}xJtryAQXz0%=d%pRPx--??Pslc$yF2xL!TdwX#b-l# zEoq)QK#d700P%|mL-HA2PW1UzrfcfeP zAh4Vm(ql}Tgsi0ho5zU2A7*#J(a$1-X)PQ5NcOe%pZPK(Pi{WA>3qW*Kk~%pgO`y> zY0E6lC(&m}^cBm+o3}2Ti+mn9(_oMuXN)NO`!NOm;SI<11Sy4{z;xj7f{TW>vS-90 ztR$dy$m6CLe_ek-j82uBKjSEuabl5kpy=}PE>*R+f0?rm$i#s0PT&XruDzkXe*msx z{dq-{N&Fgfzd`pI(U#fFg%~26cP;hQXf}@XRrMgl!LJCqb`bA+^L+lrCfRk}zn?g` zEO!>XV(yzTP`>bZ|3sJTp9YC;z{BvRWMG_tp>I$orU=ZZfXH0Hb}78WR3LI!$oGMU z^oupMGueBdXs%cVK`D+r=(X}Ne+~E$i0=*7qvV~&EsxjOT2ddQA8S5&y4d=il<%KB z8*%s-iyk39T;=BgPf!Df++^1|h0+3#2E(_Pb31<~Ie+Kdx4atR8|!wF+UXNk@a~0# zdQx6soq&Q=WD9KfxqMZvqdlZo=Fy3W{dgrgrKTbA%ML}B)MfGn!4%>}yaHYTcS8t- zrr`8USw!KvxYYMykIyNt*m0yxn72Fb}JXe>3j zhgY_SWrR4gY+*s|(>C#bCPnx8TK{ypb*WZO2SiC40J?y6d&s@s?!efC=;_|}!$7$- z#kGko2iJ>ZKU|V~Q+|^-GUF^~=jRLD<3|7vYz~0*z{dg9xUJ{hIo+!5L=VNU+0R|% z028w=9;Kf~NX3h4%GiB7?grMlkf_KF=$(&2^F;xk9kf?5&V(nzRQ?e=bt`>QFus=k zctfr`+>MFtlQB_KFMv}7Rxm>EG?b&B*WI>wRX>ZUb^JHxddDW_66EImws&V(v)3bZ zh^$X}F9NGg0BlY{@aG3u;<7A&`Scv z`*Tt1vBKlpu8@Ik7=Or*efQh%4Vyg%`oB0xNut@vQdjFwGyynyP~nBR_Ds-{3)Ppi zTcNYRs@wfl`#R2FgR&X3bvK~_?Y#`XP%~M{ePa;{P~oc}1hwex#G<6SM$p&RIl9o& zI~C5Y&;JnIZLkimdCXUvVX<{-vFWD1G_a-kKp`9Acv)c47If=!OSILr7cdp>9W+Q0 z>;(j%&jdcE+W3<4#;4J@i-4X;^L{t$J+#%oN6lruWa%l-bbq`UI$+)KgH8|x zT?)=n*B2)?a}al+A;2BmMX?n9qB)HE&lfxCNSMA))NO(@n}gj7-o&d+ zvig)C*z3D>e}YV&ESS^*h4c z@Gj;fO|sgL8D_09K>K_TLa;A9H)VzQb1AKL0V8X>_J=Eh0 z4tVqAO?$L|MxPdI?N2#LQ#G(s{kNBH70{`X6uTDFSl^C`%~qbP7%719+N`yq{F1XR)~I@$XI0Kyu(5 zkIP>fJ&EnDUlY0#%yPi&Q-rm&BhELq0|kSmvCz`d!aHygM42%rh1|EDvui z0W_koXwnEf0nrF!6F1AHdE)r)b#VScd!BI$!$02gsY!K43A!^$fmFN#kQ`lZ;#KB8XQLP9I+RxH2WFNV7_f%U7 z-jp<>W_rYX=Mu;5`$bv-0!vh~pbUj~jNZiN`9Q1Y08}S~JvtjYQwk zzDs_yTxGfHG0AlcSUDh)1<8|z0~C94{1v`4j8@aICgG7%@%v%J)_)01c7*j3FX z9KJcAp#_u)f&C3|^iR*NQx1WwTOY&LIXr8hd-*UtiMX>s<(i7kSmp60>Vkb>A@I%k zM1U)Z&|0NisPFkXV%fdbn0RhsbR>a(cKV|j{oSV(3?JF>3MYnt+L~4X4%W$zkeAyY zC~NG`v(ny{=^&QJ4#|g`|Im1z{S_3wU1UBLHQ^KA*pY(=;A92Fph+ZP)ftj5OFBZO zQV(k>8zgwg1X#&P3SZC$;@%EM=X}w~r=dah8IPTu_YpLj(rWs~@#5)(5P0uF^ zx?ADj3-U)fpSe^*mU}%pewB^nR7o|@b7!0+>y27IW-duOPi}JxBW&M zHV!Oj*>!X;_iL^lS>K)2`vATJYJDMfl@dTkE{ISEs$=;!XWv(>apd08Zug9^W!j1d zxJU#CMh!}LjjL}~k>d(M@t*Wh6!AqaNOtP*$kCA46g>0oOPo{;Ll-~6*`B>qsm!rz zliLG6CL;tUz`}_bQH!z^eT5{VwQ*>?RaK&K_BbNEZ+7h_?Mk9G36c8xN{#0U0ytSP z4F+-9>szSr?YsQczh_;5!!hnl;o^PjtRgB~R6~AY=8ilOv7qOd2S7rBR3pS(ojs@; z$FrpAHgQD>Tu;BRbm8tlRB<@SAN}~lQHF7O{M%=L_GVD?DMmBig3_r@G&icBiv@jUyw|ecdVb;VzI2KAOazm4BR`5{HefB& z>yixzfCFVbP%T*o*dYy>mK*U0)&@Mc6y#FUQfwXz8$WtUchBa@sgWzu^;yiJibHaI zP?`WaOgracI)%y?Pq%*y4TNV$uvw~K37fFG9HPyw#2V~%GwuFmSik^m3qm?*lO3pQ zGjdC}T5-BUSr;cUQOR`qyNlWQnc8N3UEtiR1|wEMAb^97O@=IIaBa}rjx`?Kbg3dO zAjuQ2`i+&C?M2RK%ciw&P3?Lt;Sff@1x!5nKZ7^9FLZp^|Et)x@4Vb!PE753=ai|rJu?_d^_wizxB^&`+lHESfAX`Gdm^ui)+}n#<6S;B|4aJx%pMGYw<#Qy8+j@U=vpIZm*>maM*W)(oW)4tiB?lIbL)=_&9u<$uQQ%BvTe=eFpfg&%z?)>n z$6M8!v69*6y2E2-U=RY}faMFtAOD_DnXm&pZ@K~lG|9{QYw8rQfI$kD&_Plt z@O(__{Yn<}2nCV-Sz+NMJG;J-dxo|ZiRlQ_p|Lk+gtwz^2Mr+PovlFzvf67Q1(tauFcQ)%xF#Yn}Y3W4r zv_@nv`2>zn(d8Gn3)<(nE+I*d+_ zm?K3p#fV4l(N%*+dKpkQ0Y9w!Ayh+#$_M@**h7Ik#9j}(iPF;KAAQuzECkz4PwNn^mmzz4eWyzms##zPe=WG`$um3fK;4gl+6yPfS1$ScM$m`oHK6M;Xx+ zW~XQ3s&%k#bH6{?W`=Hr=;Hx5Wyxcfk$L>EIJB{}a3snlu>(3aibPgvv^}Ix(Z-`l z9QZ4>ZG__V&2gF!i^E_eM!=+aC`A(i&4dO=^+!{#I$Be_MH%If7JqLpOjUbJLAVTp7F>=pe$NM0 zsS=bvr!#6%|AclrO1au_q2XB)uwE6xAbo@&tdB$C+%Pze?bdj|w?mJWj(!(!-G7z( zc13@?y43VSg;Gp37dWddNVp)lJ1CA6!QII68g~@U;bcbatg$z!b#F+|F2W79@Gm`< z(vbLLUZ_?+CV%_*=GE7j+z8hmaOpw`W(AjXh~km}@0wntk!9oEGP}luhnbsCboXtY z6XSss2-{kVkO=iq2QPqIC%oKxW$85hgOF~21fS%aKXKY#I2`v)*Nj+ZTU2QPnZdp~ zFoy=t-Ho+mi2dLwww8vYiV)cL?tewSuSE+ta@F15-)Zg*cZ|tmZ^ZiE?i){g!r?iA zEM+9%3i(YRJQw}5@Qo?yLnVPh;@wj!%-mv$Kh_;7FM!{U$1el%^WXDlSS9Styn?&? zPVI)k7Mtl_cUmgXXlHt`&tSJ(BGdK?kQ@rIvVDZ@u)jry*vHC(qUrzo1t!ShxFbr! zUyrokvM4*b5b{R-XD$WKrrqBa?z-#@o)3e>+$VX?@kq`{dVM`>FX!fq+;^8cebTt_ zpWeK;mWUS6_o_W^U0rXH9H>a}93iJN1qwLqAndKJf}7)T6Qnrz?AChvin^jJNx|7q!oCw@TdZ?&EXjT z=|jDN?;PE+S@-NKUhw3#%|twXFk+1zj&3F5uy(5+Z`@lHRA}&nX$epP%FKCp;gZh) zrLfpB7Dmct-GM}>`DSznM$#?$rob2fs@}dPn+I+_=z)ahEPVKbvbj?1*(f)aQvIfG z(Y$KrvSheZ&SM&8bF0gTj<@s%??*~lSOFy75q#m9MvQbJG#LL3V?OE+5~UMMl*llU zY2!-E)YSdTM*jPy7d32?>DGnLAr8EmPYLcVsPxW9FlI=U zKRIHJB#CSV|6YNnf0q&IIuKDX-_;b4T^dO5i@Q+izh0+yXc$qQH|EnsSmC5%m;q+w z@CiU{-gn*{HN|5_>T{bUThr$C`Z^v^`5-|GXu%j zobDc+tG7P=<TO)Ve%Ew#;4ke0uv`R%LBIo!XU2KK%I8aGPk&Pp&W}E99kJgQ zn?Ot86?BUq-}R>A6KuDQ0x2ulP!ni;M?pF&SmiMGqoxHzasW#iJN7V}*UCrh5wke$ zjvoskwWvAp4ZI?i)Aq4shyes0!JUV z>k>hinphN`j}N@B(+6AZexLdF@>#3`6H_t8gvXX?+i2F7et5rZ4BRk6ZhQ%ca!=s? zd~Z`PPgy+LNPZ%*kflzB>-~z1cycR?%a1QlE8KrP0|*G_=JMRHBz zNrm$8kH?ocaXwnMI}r7H7sM@KFpcMfpd@S@3Ub`b%sR?~1O_I>9Rsg0|A)?8ueZK0 zXx*qzpLlQ&+xcUFW!(>*y8uo>2pMy4%0R(Ax4Xh495v1qJnm#%t(?zIS}4EjM_RV$ z7D$tUen}711%i$Nu!9AD?~&E0d&pJoy23kD5cX4@dRwaOW{D!z>r)v{;;4F$J7m)~ zOCaS478oOai-Z(JjtuZ8u1&U0g(7*4v`qJFk6S-Cn0X^diZ9P{>{~w1_~eOJ1)FDx z3`hiljR{Z&5NmRh{M(u=gIa!qEP+_RYwbY}7S8(K{Nr~oucnO?ssb>OiGXajzo^@5 z2z`+0_C4~E3nNxM0U;4D+cdp6wPh%)wFONNEzvg2u9o8mL0|akvd_75FOM;U@p<#t z-{t+fxX&L|+|$$vEt!dJsd*T>PChU37G{s%0OM}qa1B$a?+M-ulCQO-TPNMO_R!YF z>l4m={=NOxMUH1ZivCq)f_pFr9PD95;2C!wf*n|7H>kON;FJF2!T4#Iq}|@3C9Zn5 z0812>;fE2E6Kya~1r&rJm@^!jtqYipttfPMY_-lkmOt*{Lnrh@zesH!c`xIvyj}th zt$2N9@Hx;p14Y+9B%qiqWzmr}2Fq9Ob*V`5g9S<%X&m|;vztmg*Ybz{ZoEJTWe%X2 z6{$m_!000=Oyi?7rgZE0hbRLxwuOhjl5qsu0%q4__NA@Rsh=+;weY|`4q2MvRa8gg z(o_EzxE>+C6*~sMdBuOdr09~5bglPUIyRlSAfdzG1av&`@}b9?`VmD&Ppr|#RFR>O z8&xAA-Qha>)$h`^o*rm!t9a*l-5>c0^5=@Opv)5Cjr`7qsy%_-g^tI#(c zz;whw3+F=fK$CePjfPHvFc0$K#_sEg)U`IP(oZb;dZ~p+a;}X_zeLhTDT&t#gzzOc z#KMqLgVf~TJD*#xj2LdoUVO%nRm>NEv7GEWt{Q7X_;= z3d*0mvsgb=lw(Z$u)h}eQ6I9AL|_6D0BlC6kEiJmiW@ZCrjM5rr@zH#M+;q%_vhCi z6{S71u5TR?zG}fb&e#o}GN{~y@*AOh#0YmEW^nxCbm-rQWfr=3r>uYM+gB=O;{$jJVP>NQ5XYkL@+f>kZgZyWke)*tIqjT`+L z7KSAmY-o?SllCrmFh*D()na7=;1SSV z0R=bW+aMl+Va$S{^8fYE|CqlHXC@5#TCQdNLcJ%mGQH6$Z!U3j23-4jw*AgO;gKl~ zlI)50^G91W2gKh@I-jLF8{K`?WzR2RSN9{f5HCBn#4VE*jKr}#tW2X!>TCBGx&nAhUJzt0p%8K?)X<4=E?~s}KYspW{yLDe zV{+$TU7n$Te3(6$AbeFsx1;v8%{7w2yEombm${I*7vf*^wTx8S&S7p$cN$Y`c(Y}0 zy0ohE)9AD9x8G;~(tuGY3n~E+IC!2<{@A({FlWqnLGI53`TIWuV$8842!+EQNAdpg zd7$cgueJrS8b2r}N65Ll4aodOc^L@Q@enT((Vgsw%N|Cj&hsa|iF8oxDs^3QhD19v z%^v=H-Jf^;RR#_Y-EO@zJcuJx=fgT6b^PrekO4S8K zyDu!m`5&y|6h^q7|Gz7Tp@?%I-(`Jvyc((pPYy#VMh6s0!t9T3%ylb0@}s@)tPL5w zZn{k?CkSO`M*%oc^#sY-LolfyvL$?rH*`!^%?ax3%R_pvYb)|$_fB_?UTbnaHIv0h3Rg-A-+QB**Z>ZQ6(|A_1j=8aFvkH*@kAJ&E$6X(U(RH)y+9(mz5KA>OTjAakIamyweBiE{akyK`mW>KDgXzB zEfmYiFGSfC2gg=e?86-aM;SxML9M(R@?{S~{4PfLB|NrA7cWud2XHVv5hmT~`7Zc) zb?Lp&m^e)*?J1kCtyC^)39lFxZn}@e7hofItExat5 zEj0*o52pF_H6;J@3@<$|fCJ0gA#J?7hkyh3P+9s)wUu@(@=nNm;PYkyHB0s7cI2zOfAU8EDWx=ESs<22C6Q8Q8_-Qh@K3EpFJHxj6ijOX9TH^)$>}@ zhiu;$om3kw{$6@mfK&D@SP4^&)W?9aU3}QyM^}eb4@g8gU`irXRiGb=F1y8AmABPg zb~_I+1*0;J_6hc-+K#U~a}hNjm9LCCI>OX5a2*imi(f<0g?v@7;0n%gm>kn9dnw%; z-l0@iWEQL6=_rMy^bD2av%ySx*iKhCT`JErygXVTuAM%x&zl&>zGRSW==892Ux>-! zb{r+0pL7@=8E_rsfTsyncl{YcJ@>M%J;(Y#bC=1C<;hyrJvncV1yeZb4dG8%mnpH) ze5(dQBRDE<<27m%clOpCKe=9%yx+X%{!9iWd0?Xoq1yGe1r(l^ zY#hJ%MoUjkjP5VHwvoKnx_~KrMw6QaQuLvi1(hGjDj=IW7m}IMzb_W z7f~1qofkCT()d)hoNH2{&8OOOD9Q@pSGB75YkA=+L`x$lw83tM; zOr^usBEnF0bb0r{u@!rptA&%uXRz3FZ+lBe_PdWz@6hCJ2@V5P;QQQZ}*OGidSLPaEf3OBV=P`XFvx)S{=w>GD5MR{|P?;WI8qeI1&oU44|mT z6Il-lkmtB)nBk~zJI?W*Qg|18{WDTAM2fu;;uRWOw$Io9VSlV}^^#9C-;1*~j z-S^S7f5A6TKvi-XRj3Da`fqx|GxVvL%ljm9AM(w-BZ4v=R_zHIr^OfUSQ!heI~n+|Wab7q_Ap7O6?GqNK6M);L&j*->Lb#@nbYOK|*HFmQ? z3aL2d3<^JVh&V_!bBisV?W%n00EtNar@xMyPv2=j?XT>I*&zZTxdeZKQ-df@6Y+na z?udEm`Dk<`0k6#U!0wi{t(~vW9B)ggIV6bZp8}^1Y=nT4a0$MsgMJw6`Lc(``%|xC z$=r1MXS2tfi_Lc8terCVi zL@VnvXY4lU3Fd^gR$J(02jSqC6l%wh2IE}XW9Q)2e@b z)rPsEuuVa5xS(@6)*y}je&$VVoI0LBc){nU995b#`R4x>f zD1=HtfIbz3DM*!8i8Da?b(BhmwUNkCL$UT% zVf0PB=BDgi))&|Oevb<*;HyaEGgV>59RfQ7H1t6M$S7!b2*6WPo?j4MXNcMN(w3cT zldIn48{BB8#+R}61E?AF>n1@lrVt2bKmpdZAk?$OHOf`}dhyC4P0vNQI$Ev7m(urW zUXc2T@+j}V$xtq326|l#!ZYaJr~=?XT^ud~7=bbTw!>_hn$|H`Q4-a1x9ugOTL=Y&Yy#Zw? z&d%M-WaXPypG9JS&5gF)ZDw!_-X^-V?6QiJXv@lOvts$b2}Y; z2OtP#wzn%$(qMO=XiHY3)l)mzGGVE4mq;rhsJ!Lzj}g=QB;U_iussSga^P49{;&Rm z;48o%dnWz9%~?l$2Y=R7r@E$gSHAde=NnL_|by) z=s9lQ)HRNvneX2+-TE`m#v83MObB*W*xtUMl6?=<3s{;8-Pa_TJ_tFOVJ8f1+&+uS z*lCI@V=Zw@GYnLk5p}6f1FN4*nAl0MLFiBp3=4&SZfF{@4GN&y#49Pv%Xi%|{K1Rs zGzQ{Y)AxU0wa%Y-^+JcK#!Vd79}I@5L4nauC~^qEzTZ&tlo)9(#*xml{GCv2Yn>nX zeMm>hWq!n&cp};xyi$1u5a2{`aZfKwdYKb6OY083@QUj3Z%;2|5NCKAxAwb#!uOvk zO$BC+r71kyCk(*_oENYO;?gwB5b}ITea3~g@=U_Hp_uK9moo$BQ;ox=t@rnUm!JS# zO31qLglccWty|q(?~#4`@1Ehu4h^1#+s+Ca)z@1buQ20ZefT}5l7SGwfl^;+A^b=a zN(${&M(w=3SSLQ|Rhe2Zfm!@QKrD9sP5J8QSjVS1a{7Q<6kw}>5zb*56!-;ndCZGm z=yvn1j;wh~pu_AAMcJ0^Xf$J<-UlU3{eKg=HbBY4vSbLj;bPRSwc-eud)$07YhcAWn4tUV_b(X+F#rd$Cs4X}d;k@G7kwe7r%1DIFvK?UDI;gCY%`g{ ztmunblzC9>=8rlFS^x*CH6Udk(*_NizI*AJ8Zd^W(fH6XtjR8cNf7RMXe`qB?x0BE z5o8o0iZGlt2YdYcSg9Oyao?AUQp_3`oot@vtvId~m+ZyAkc>ixV_siVyw_#;Vm3po zbe7~~-ZPKo5mE1g;39eY>*H51--GlB$e$u-q<;8_;0JI&Nt|u$-gUR=MiSgVy~*)v zSvV$8Q{VieBXP@r{l-(zRM_hR&JpB78P9{ne5v7Sx2bqsy&VTM-n^w!d#=tBV|JQ*Ohwf-)0G^jk~5{*;ijQPxm|{ z_IJj#K$6{XIyu5KLPHIc!h5f

UA01mk_x-eoMFT--vj$_n6ofj$uAlGq>Tjbi($ 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 z zMWs~fZ+bDeOl_vm`>afN$F51}bo1WIS5t^KMwRab59pFRkTxAS?{SauCTRu5Gv-@c zk+d8cTf?U2ERO5WjyWF;>9P#&i-R1r=^*9zltXmPxfMKlm4CGl2YxpV(Dj3VfVS527UyT$cb@lMMXzHVNH8&}Shzsxne7hAZw@qUYZ zQoo$@CM2?<;Q;uI_AT?mA&N@cEpywVm$=R%YtXkgsHj85l!fAn-j*WU1ELE=On5se z?^fiXeWuR?qojg+=aO7<{;uGZ{F345d3e7mgsoXgXVt55|N`OK^d#QbMnD^?)yY}&gFm}RiOlZP`Q~C_GM>B^T%E&ZyMAQ`rW+)vQz)*0~m=+9*z25W{77_NCRHB~*Y?n}?8jjrTuyLeHaV9$8o zZy@U#LGedaP6^s>(AR9^u;-e&VVv?35%vmp6t93nson_xvCb=$-anFZBD}+;wl9Q$ z983>KxHapLX?1Wtsf#yKXX~h=mY?@znZ;ckbq&%k$$~K{mL10!q_zK8fp-fdei3hT zF9o9>CP$A}^mS?X+DwzmlCBph{7$8IsK33@!>LX_#8v$k5a04Z-GJowf+olhJSE4F z#MyfNypOCIHxjcp6`oc9o)k;!K1x2DDNHOqFA+qIqaeVL0J&{MInO&jml9^bl=W-v z?@#W%0W8hoR~J2`V=|6YES=)zD&(OiR)9(#TFd@DjGg|H72!_)`^GNXc>h!H$i=Qw z154JcN#~yiGxML3oxum&qbMXGj+A>d$1$;a*RtZ>3qPK6pFf+?^YH4*PIEDqn-OJj z7^OWm$>qIEkg5UK;Gjrf--g)^?Tql_X_JAtKbNAGdfbBZnNM+zpCC)a9U!d5cRiaA zsqOs~6ndTQhg6P94fKKfYg0S8nNx2GUBYjDn*FPzu@pf&c5JDe*td!ho?_d);g%QNvqudNJKu{3nCgxW^mG7`9bJOr)3A211->Jp4YF zE=@T*{lQU$T!k`Fav@z{KRq$AGW{2gcrCnJm(KjqI%}KYosC;_nLJ{q;Rt_TJ98Ub;gQBYLyYCFN`ylMJrj8HSgf{{SZ-wdqYSZCy|_KZ_njUz?ma4pwvc&lq55&e z^@fwbC$H19X&U6rL<-Hitm}3Mg=-!x#MjBNAnz!ly_}9xWv9bC&Noc-OK+NMt+GBW zS0uZP;(^*$kT~c{@2$tE8P~cvN5|R=b#E`q%${LtNSH4^d#Cu>yL%CS!DaHg5+-mF zl*B|3H4{-s_8)~VjH~uv2LbLczG1)670p#57*4=JC1KP=WnYjkf2Pi1YLhb!YKI01 z0do5B2a8|HTp_YH(4nn5&ADN@*Ka>VDRcW+cs_r0x6raI_4j%3prHJLz{1-Al7`xS zP$CKmyCcu@L(+t@mR(M|lvpvpqR3^LcBd(3ZYN)60Dc)DT!hYSbTqizfjPA=ii>1v zZ`E9voNu(JA+Z4j?l%K(|_-6i%*FsQ<+! zrfT&|wd(3Up+WgbyGUkZtcSR5=kD`>oH(!!p_QvwFJ_ZZW9gZP@S0^vz0l(R_p1EeJH|3aRjON7nzU++Y%j2I2agDGG}tm?HKv1r@a-$!b$OrKcDBi;NUDY zT0(*fK>Y``?=U2>2y!nssAEnaTQm=9)YLQeDCiLXL!5N%3l4ujS;I&`KoZoARgG&XxFOOIs(=u%~SZ`x`^pJA##iY+V(AOt|SLh4}OgikFw zLeScQtS=vUV}#KrF(rP?$(Lb(z+6=^`gfe&vw0CS4Q(9i=B-py8l@jvOwh0cjn@0C z`?Nj^l9lznl;$R+Y_WcCPfZALw|$}VP0YITU-4cm`pMnmYl}S+9|jVR)^-fR%>ph+5dcZ>H=o4KNCrKn)*wU@7RC%AGyaW^r;r{o2&tbM+a%#$nKulxI4DX&7 z`zM|6<9W6`vMvG@cZKuL z5R6QY|FR+vzo<*M`qRsP@HJ^V2Rm&(ImFm26^nRxhG$x!{%TkqDHp1G1nlTh-eZv2wi8a$@t zc4wMG?n#pT2+B)d*D6>{(moMUp?c zbAp__m>^P6`w0&lLHp<{X+O#SEzMEM@3pNO|1m!({R!#gT+OpbE`>3Q^Q>N>CRGvy zv=72n`RA}9X6wx|%{`_GGS|KWyoQmLf79L%-bUVym=J{_ba(t-q= z@B@1-A9?W&QcqWpg^Hb1x#=Ji_jM5*A z?2H>sZie{|SOhp&3|N&^II?*AmTY3b))jpRk7||Lf1sn_y@lHoJvF`jQ~H;vro|R& zbzcmGTv<7=WWOd^P8(UzYccf&es&qhuT}fpExq!2b4rC$#q?9qYc{Y*kXlB5cy{lh zrpLMYOcZE@Y90Cc&PGl5eV6GXv^9U-_hwu@SNNhsJSrC;h@>YYfO`P(Qu8&mJ4?yd zyh3A~GnHSk3;F0Z-z!iv(6b5n(%yYx#|#Vvpt#WXul}&7-?Ur)_h+qBO4+Mig#qoc zb!GJZG*{TwPoL@`PIOaET?PYzvPWp|Z}gCGyxBm9b$hejC(todrm{R-+&l6|`Zn%}>tpWg|8;RFgFCV3ys zuxi8DTT9tds+JC%X>03uk14)niAS*iJ$5EB`r%#QcbfNYMCnk5Li`~1jXum0zpY}K z9sfBbr!B}9$XWdbKQP5Og17{`dHC)VLfRAm31pzq(O11T6RUaGL#{)Qsu+;z$y;-&>(j~P(4 zNAXJ0^mzw>R)xV{Ah>TW77tVW?b*oe0_v>E^Pif%?#UX!T2|0bY~L`60y>8 zA=VH9uqOhhi(JF#4|AIM>$W7WXYH&@6%%Z>o<@m_PZt_6v8=U(mhfPeLSi=65Ve1IVt#*hDbn7x`ozDZMR?QX!y;cORkh<=!AE`N{_zh@ML}A-ASVy=4AAG71S{vU_(p{MkYS&Nadla*ncP-60cV2j%k?y(`N7Wo` z0aglV+z}vCDpHvPxkly~L4wH(J^i{hYnP0jem|u%rMHRZD_~I-(GuopmBiCX zN&)Jc#79$C2JZ`9`-SHbJ)bnYC#y$$%|s>vthYR*8j)x(^*zQ4=PSrMpSovbpdQn- zRbOm3B4c=@=8Iwg+sT5RaC1GJQILaFBl7#+9s<0!R8rh%o*EBd!u6Qww)D_6`uX;C z7X7i(l(5rk84g8cASWkyFnD48E#|%qW}ki?!xV0;bNZMcmy2c=bMas4YGEPU81ZoD z?>0%=Ag2s7718%BVh*z}5vfn_3j+Xm_0OsJ_lWq92 zmrWEKB689No{GZ=1|kga$U zFJ-<`mYz_p8P9wALwBS!o8r{JpIrk$^W-8hGt6FHn!(~;2wQG`!Iqg_SttC@l ze`ou&g5!b84nV~jy-xqb7MSvHGDB8hmj&0_HrdbpY<+UuHtb}uiNUFOuVBg7><*yk zmHC0k9<2wv^D*x>)a2p(F`OqxLW#Logmp@OMV)WgeomDpn8-8Ufs5~R9u>92G;_3` zC_rXg!hT*eW(*liV4&QgBkoBO-L#N@(mLV9=;`ng_nN9t(KoPT%1ROdF+%I5d?ebJ z$0h+rFFaXq5^OwdN-R7QK)HJP6JQhJ0l^m*j_kgh@o&GB^tm6W_Ob3ri1nHq?dwy4 z?VAP;d|zo7J*O=NBfKs6G!GQkg35)66pnCleC?8a{3G=`@fX^D^Sts{x3>|LBJh5r z4{in!ts)o6?Kj47bTZ-8M?MI=QZp|}62~`ReT~D@B|~MQZ}Pc>Sr3KlS=0rD&Qr7l z`6~x=K;Or&PSZSS)b8+je&s?#z0^ngd~Gp#LglT~zwkG#SmA(_1;h`=h`r6DLibAT zS9ahh{;z+O=nF3HaU?SVpN5Ca(v5)!yec=Z~i@5jhhg0O_`~CC2CB@yj z$#J~!v^+OKZ-Gw?{`Bj|ocL|KS;E?x;P8MKix}D;P;EvG!&b}HvvPN7FO|=qA`bR! z_|>+m+#zSbMt*cVbGtHc1P9~*0*dfU_#HwTd`mdb{1V!laSmxta{3wJXy5vEN?#~2 zw7%dDovcHU5I8&vz)gqV=YUSkK1bhpI>|nLg7D#a-nQaf6yt6QM!Q2#PslIWl3pcn z5G4l(1iYcv{A$o~!(C+hIUm&Svq%{5O%y>`kT4bS%6e2M#`B z_@*H;M*Tk6_htM~Ezjeg-kjEvZxOW!;d5T^yAjcR@heY>MCCaH3%C!$C@2~_5wdx> zFNrK1DR?G3wmn$tq{=T&Dw(~s{D(gpBh`|8JEg_$Lp2z70brU%%T0t~*4g=ScPBEY zDc_NoJY?RnM8NE(*WJ-O6mzvkY&&dBjR|0AA*YQLg_aUA>pb((M?Z+`K zJMB((fPT<)#LK0fc&4Mz*g;XlZt^3nGl4l6g?mY6m&EV_gE5x`fdbxS&CuGPB2n|) z58ZnqEWSoxFZ=>S3upnP=+!!gF%04V`uOp6V;-H8zvZX8tJ376wM#s4G9vR4!Tu%`gYi##xnAtWzhGnjoO?5=Y8cAso@ zyj-l_>USW+>(=#}rAj*Qbv(&xA-X$YC>0dJ!9^RcR2Z6y+!Hf*!Z2@j2gjn;klmo~ z7sNxlcvRbiR3_6%71_SrQ*H%=z%K#gDfboMU!)};?$;pk<6!*d=IEDw3FM3SOt_?j z^YvN>g}3jf`B7n$^w@zMVCs-GdgmL=J76>juJPyAO?Pqh;dvp%)Th?zeZ*EusdaVC zZ54OIAqC{1sDOmyf8jnO870L&dEdlOG_5zzck+C{Hms``T{~-ePQ|cGn^=8{!eU~- zN3}VeaX-L?ef$s*aQ`IX>znK`opx```t+n*NIAs4U6sX!p>S zw;a2w&5F0}$~>a`3hy5T+BDNwAJH=GCYTJrZy=RAvvJ|-!@lb}J!#2?S0c69hJ}Do zLmt+FSn48#$r^q@O4zcqA-BtDGqGIJ-Lrlq9`AMLi`SVG!$_1XUdn!t0MA?khDo5; zpPopCCcrr;xucj@_N@qpbhr(K=#Nq+op7hi(M_)I^mzOy@<0pyG!2MQCN_HRSn1m+f*Fl*h` zX#L>*puwZEl1f2O`<7hBRGt6vICJvW^LlkqJWvK+SfoQY9mf9ccijG8>0y90>0te6 zV$3p@sYoZ!wS^qVNFv>xT#dogzg1&~u%D9oDOF-Qd=WlazwMKM+>Gt~!E@rJvzkZK zYTPT1pS2$_VW7kPn zNdN9PxdtKR2L2?S=@K8(T?Ccf-eHO-t?~x-_sm)n2+iyPnESSiF#hUaYT|mGq{eX;HRHF zB%FW~>Oh}mO=0wfGXEp95BLSTMU=@r?bC5y*;Pz`s#&QRJ#X9>(`$PQ=`;vzp?z`x zq$k|T_j9N4dtA-1mYH4k>m}bm>8g%wG;HDju5vWu^3t|{f)cA1el#_qh%(wZL~LU! zmu0P)Dh5ump=y&wiUtE>ezwFvLdElLK7MZa$-VuN{vI&a2^_Sf4SmAs_|t+S7x?md zn*Nc>p8m{YJ+{m3bz7}KZqL){OqoWaM-A8_SR-;_d^sElB{Q%pek`HyA_ZaIQC zO(*k4an~96q3Hq;<`AUpZ%GkC5C(EoLC%9t{VxdQm`zK?7ftgitt03 zB&a>0WAAT;s`A3!;|;h zufCQ9*R%CFurFm7^5e5-G}_a9N*!#QtyK2M%2U4rCRB$mZREU|yUTH^falYQxrFX7 zqNuIhEr??TAl^k^iqXRa-y&UL&epJ|p&QIq0 zV!A$?trm@Zl9=S~Td~}0Ob)#6``b_HUdm7!eU(sHzFi2+1QOr}rM0i?CXrEUD4j+1 zM3TMKrU(Cb&~SyH57Wrw+aY&ztbd=L_%L!UjQA!T25NpLT5hx#a~NLXPp;Bz*GvYE z7TSKUvBll_7Ea6m!lqd=MdXc9jFA?EO#o6uIusfXiRvk}#kjdU4Q*fFOs=DEzYNSs zE5z+&rjbUc9BYUc>#0Ew`X~^GBnrXUz&h2Rb59-NC5h5wFZh+F?ya{NRCZlsZ&gd> zAGsbw=n;6ELNMG1!G3KXcBc5;wq2#(Qhs~?$W!TMQlgE*AifWe35plFIY>pwg`b1Y z5>keI4Ep$*Coyl@xcyOaX(@ZV>l9`FqRBDkGFL5A?)!79WKB)hKU`_SREh8dwjOOe z{E&PF=vFPs8NKI}Y<%=%JvY6aMrt-07uJVqHQx|YNVz|e;stCKT+xG3coT=ZZY_uK z;@v-NzPTF< zMpEt5pO%wott-~FW+DFy!>o~fT3HBMi@-T(op)oLsd;xRL+$>ORYY*_YrSxi0?m=o z%vapUi`L&MfI|iiZAfG1KpJL0=ZNnlQ5Vq}7aVaL8E-g&`_LeYqW!pq7Qd~U)q_u4 zP_UMe1C$i{IedraUL;J&SJ5EHkJFKn`?II@_FRsk)9?pTZdX41Mb3#bL!-N|AWRcv z=&41AX|TQ-y#|?0LQ&JV!nrpx#WFs$Om;^Exib5Q*oao!`}05;DTe}&qt82L1GB!f zU+^}2DL5y3>l=N)vt6NYrD57E{ZSqvtILV6Z?^0Ja`3wlP*p<_raD`q>TJh4zd$A- zOrUH<>zcMQT6^xrHnY`3kLJ%bBlJ1@VPu8}hS6$l3iEoJ$l+_tcCe37m;0SYv(0_BqR5G zxZ+w%*&wHg8h*F`z5^;T=R7!*W5&bv^!}Y(ftCJnQVKVvmWf`A1Kt7!3=TLX}lsPV}H@y=xE? zj%(8X2_s~4vl%XsYdKlcZKW8erXsni;^sjTZT-EbcLC&-P%N1H>x}(_QG2ew`M^A<`GH`s^bD^xuI{E`zR@7`Y`sGCSwC7OI3t` zL$ne%E}et9ee*$`a|Gb{#T2)_!4X3vVVPtMoRNIoIo`Y$I@vqn~xEAEt2(8-JCIRYCJ>#+uZC=*zFREiFnW zW6uLW$%(&pBmBf+0dkN&LokII(Aa}mN7Id2TGqD~Li*qT6~vS2eg) zl;T}{GzR2giYnr2dF~x>_flhpQem-T*I@}>#*>A(9}AlmxC*cmsR4P9jTO4@7NEI% z%gl?h`d4W5M;wnn+bwL8oRYahDw$aQ?8@;q&oJ?x(1V5OuMKt>Ip=utY#zUS@$u*P zh18vYImAR`D#)(Bi**brMAf0hz#HDbcWcN!hkG|IXCdRzKGlCB#_?hh(WF0}qS$~= zZAvw9Lyp9WtTi0agD`L$v46j(DAC-#tf)2rx4->Gf85VSm$}AY=TqpEc=Cosc~^$$ zT3z9Hh9I*PuVtJdc^ZXcmHkD-$9;TAz1bP3I`~IV=nC{MHLmdsowhv6CoyHY7|`#N z48{py#s>uPRfk2soqGA|Y3<+m#f9ddIi{+Ts_Q(?rhNQMARA$@ zXbz?zVT5p+>L7K2TK9fXy}x2~{-P|B`CmX;-q7FkNwI(GZWgRP{P=T^fUo$@tYO(3 zKKjUm6%!ZxP~6f!`}lTTL|XHW(5cCKrYg&V;Zi;^#V@{=*De4Y3(7Y_==-0SjB%1> z>6XqL60JQXp6e6PrWNZ-8$FTUB7f6!{_;-yWghk|+H>6${s3WahK1{E5Q{js#4 zI6q4<=W}-2n#25tqSAo z(!xZChRkH*%OLS*tDj@!8*7gLdcC=Ge(h}|XgR>lAs~g|_9G-5u&XTl5rizP_ka7_ zztd>S<_d0_V8w;N(a?+7;Ub}&**!-Dj*?2q$(-lPJcq+a!+L-OdBnzvm8`6PiGbl5 zmu=aYUiQ?+E2AXQvY7395O$5PjD zHg_5mey?3|_tSvEU)M(PpcG*cJQ97Ee4|45MY$a=TK4cC_y1{s>23Sy&kB$37~*wl zY_-ocB592S(WMN@%Fd)#o#6&&w*Ni8g$dpGj%f@2Zq+z7XZrP|%%)2)75N#O?rV}l zmbYYfD7Hu8tf5T={Hy)7w|~bx$7iOmCT{d+s_VFf2D!KrQvL2u>-qj{&(NF1={d(a zpnxKQA>9Wf0Ni1WHKOjnJjSIKc-Hnc+)(+FDABr_qQMQ5b-l*mw(qg46W_8l;7$V4 z4(V_0L(CHFmHoYo0XC9pRJUwr`o_Oq$BDVmr10|A(>EjpGZ&2IIlrKy6M$o))kc3V z##=hU<3`z&<+%NLipJcqIlroZ>XbsY>DiP}SFyCUaSjyW8xS=jdz{dUS!YFjec1V+ zgaR(g08+_~t(d-q%I#q-A%k}bCk+*JKW~HA4_*%f3i5~I1p*54nJ65Wj3g$C9(9jg z_6^SwyZe!wqPl69A>w34^W}o?kVgaPI{L}&jbWC_RyK-dd)6!RMd*r8+r4)Sx6i&M zx$&9k*&|V!jMYc~Ae0Asa%dgcKZbWOuoT%&t3drwVY}kvk215kJO6fGKkKkLoIT1f z_F+}?EBgf-2%=EB6baf!4{LHi@x(QQFQyuZ7{x1^x~!b@t0N`vRc(Cid?HZ$REd5& zO8=ueg!aFeei-as&dfG?(J9=g6S^GC$RYIlBmY8HU5KmQkM(^x9Q zg`;~NA5rP17)#*Am8dbmtSY-6RImVT_UP-pk%!sGQS}qHI5pEH-{f1fKSmR)Ng61w zUG$!JFgW(}4ZYwb=pQ*bR3F*?_iB^Ta&RqmueIWr1`8CaDvoCu_s}~0`4ghJa&gi4 zv(v3)3c5TaTWUfA}Ec@w?1|1*RU1AsjA7rh&2-y zMK@!h@;3oduQx!qKG%+3%`F~H#y~3Xs*Uy^yyGc)1TR)fZVy#K}+G6 zL)QEYHADJ4yE?7v1L96XX;0?2HPnuX<4#KlrxJK(cI#4rei9Tt7_qtwjMb=12|w<% zS5EQ8%9!L2op&?j>T=FSza}94|Sc<=>UhKQ1?e98i`ZIsSlo%+E7_D{8w%Cw|$AR_>w6 z#l`B4*;CrprbIzI>B(s-YcxMlZOI3!X!a218k9_J8hgitCHqe4=Z_!k&3;8!xYTf6 z8ERQyNdELs;V;+@=oUc$1s+iULz;Xn-%xQhk$Gj1u#}&xzoa4@EjimZtr9jbncwP7 zHyc!oqHu*kYX8?w9+uS}Y4trhX7~FP+f?*WSjuHqDdN+SWQpOO-sazDs?Go;8oD>c zfW>oP?qdWdUijF4Awle1@1CY0sr$Q>Q96mT3TC!i+<5w3V=Rd*c;EJJNTop3e z4K}myo#gQA?i(W=|FDM7{7%OH=@i^1`AsZ2aoRmt#kpq~{3W>2h-I9e!1(cuvL>G^ z73;p)Yd;$r{EVNuc-OAnnuF}dMen5*{N1*zAg2hJVe|{iOUE2~?seC?mVsRbpi&U{XbIOZXVlrEHEx#pago}cK z%EJG!a8RBPD|)E$tNjktiYUjyvIiDcefFjdQiN&Vub1ZLC$ zJpzvzTq9(GQx#~B6BhV2*YVN9C7z4Nr#SP9iNz~Us*zqx?Y7?BdYmfzW{D2)8Upet zE|&cZ*L&F3lqgx&W*UV*72@?MGw#E(=EzT^FFB;Jd$(gDY#qyg~)1CUC!I%n^rzW zdCmFDP4EX4pg$RHFl)Eabu~DI;oz6`FLs2_H1Sm!rntGOvtNjNSI=tAU*^HjNyPTb z8a@Xg2=pqG5Uc=*U3+x%wxb=&tB#(Qi8z+w_vpEtshFf+|K(rtV9j-`e z`8_1B5P#r2QTEAZj?D_ivB$Oj9NFd4Q^N!a=L}D`oLG!eJ@yEq6M$esE9m~2Z%$%f zZ~BF&JUKiIfuyJZWjQVe1`>tj1~-1EEc2ZY-Anf$E(bYiqDH{Xlm9S&i&apX-0O2P zOh^1Yu3E7;+!aoaQyV(xDrGDe_sBydd=UH=n1*mbPXiVSF%d<$+T+*Mt6#HcdV9X1 zm2>O7oArTpLzKSho!(fxgAsrfQB5+4Tzm)S_jzm?%r}{=%rxbde|7AC#T=P#VYoUn zdglDN=by5^9aO7^JUEc(W0;P{eD6YTo&y!P+h5C@nMSV#LQaxgB0u&u{%M>O{h56nFseMx@xe14g{wL$StG0bm2*$63RV;YBAc)ZACggU|Ym)HB^L(nSAIXO8&N;T`qF{+{#+7MAfsD zh?EzBKtUky9?*Ue56j zAJ(@tOVDzdnyw3-iQ$g=`k_3--v@jcVd&J{ zzn&d0G24RQOnrsDYN739#0CE^+D#->V`Da}CwcW4b4S{iWHP~m!EjpeB=_YS52KX( zeDk9fUQCG_0XH5Bzo0D4Uz=5GQ~oQdSl@fWCW1AW%`j6H($2VQGXy zX3nz`>$EB@*0o^T{X`cv2`ka*{pcEy1_y{EUCpXt~VdvVfWcaKu3;^Oh$SIz1$jdl`RUf*t~h7?fD#7v7~*g(uLDi;z2;(z+U+Vu zo3X5Sbqejw+^6pS^b|?BQ%L4(^M?0dB77Ox;*flR-zG-EhK|%a@u;k_5Zv|`j9cm@ zGe}mP+~y2s!E4@Dq9C-f1m7K+agnM-s6SeB!45I!45inPWTxJ9yit)5z>rt6D;z5j z%3{m5!#c}RS-cHL1=UfchCP){iB9W*bNC-W^?%@d_J4QEegf)CdS7Hl!ui=+Pxr=0 zBOJ-JlRcL2Zpy049e-OHb2M1-z#x@AdKvxUq-1Tqf}G~DwQgNy1IqD)(1*>^w`x+v z3{&O73xsjhNH#z7khe~IQ}JiB>*>kR_Y2aqCqx8wxL!Dpi)AsHYTV)6<@a&}r$=5) z0s(QBmy?qmfdmu*YQ?hXJQ+Gko!Es>5-Nk+@xkhLdU=gogn{WNvsV++mJj|4)PJ$m zH9x?rz07lCq|T=ljJuuD%=|6oQRqe9p6%Au`-BCaizqn#a7&}lxnd5J$3kthRxd_00Sym(d@EID+Qi<3XTs|-)Kkw zi9#ZWA(j$X1HTE8R+6BB-w=u@q4OeJ0Pw z^N6xgfjzCy+nMyU)Wpg#wh*oK2i=iZj7tCizy9{`#?t^@d zGRlqErp+_Bw;_q%YV^nF6H5ngLUBF8B7fAJ(|t+B$Vh@mY9c5^(wx3YqNbv8LR<6bQ~Z* zpbqJ50c%iNbcaI{|C%s8@nd%TrL=2B)@%a|w(>oAclx}d61s9hP8s+h&=HBd2gaJ0 zq>wnUkv5jn6kNh58@Y~O=pajG=2uO%%+Xz^bz7Jn9DV=>BhFFm;dn@i-q4UuUsc9F z$)ae{%Ay>zE2BbgKMS~vbFKMw-V&Ce0t_KBBrib@&l#-9C$f@4W<~xM20PRmLA1uMp<>8B6sW{dj3)ftAdrT z<0e#eVL0Rg3Ebquk%JawkEN74)mY((un$kwdb!`9cbW8R4kC;iW;!KP;kTnExj!=y zZIg#aF~-LbPlQu9j$FmK?^-G2V@Kz(ik~F3W*=zX8D8xuh!)<0%%L3g&7tLfBK3PX zy+)C$42|JyPZf2>pG-UI#WC8N(~UAkGmP!^vf#BoN6E=UDha(SAL1}+h4J9zrxVB3$z2{no$kSG!p$T!$nwP~{(x<>wb*ex7yXv#Zv(b!fk;DHlHGkgN@PsQCPg z{R6ctX{!akG)Wa8CjwLJ(61};5Y-)!)8<-EkZUiia%Um+y3#uJg$V)uMvD_unMKB| zw#!gg1dfM;sB-L(0%^4K55da^<@1GA|2~KmH&fh`(^%@&98?d{89!EDv9}0vau6M& zqtV7}%sNFyW{&8+BfDFEC9eGJiu89klr zL3?;hDfNxbA`I&>#rFmY-+TO2Yg@l%mu@k`qP(`g>rIrte>sPpdu| zH1zm*gQ*k4cgOpbjA>`3&pU{h1xy0|B<$2~t;)cemzop?LJ`(*WHmxz@&_taz@0Yrwyn9Iu}rUCfE4!Rfb_1j36u0#Fw*%(xVyReg2#JE zM991QJ!vQP?`V>g9=~}N)mBG90iafi^Z4eTe;zJU{IsaU_qKQPJs*7jt(EL<*>B zlW3b#+l5{y?5Ax_Xu^?%`H;C!6^p+Iqx5bc>wgeZ_t!SVMxCxVet{l^j)3$9`Z=_B zV}768>{~ve^2-^<&&|TIJ!`KmdEI^e^Wj5dFJ8_c$3u8lKu$tH5J^;fFJc(88ZL@) zX5oz0JjuJQm}t9Upy{l#MfCTnA#G9W*vR;F@%+DD(nqgiHJ$Gpbt3b! ze_q0c8i}k3oP@|e7DQpr%{}7+c_jY);)O@P4@jx?lfxq;Z7p0b4qI&9HLG@}9RfL+ zHGvcgY7S8}_j*!n6u&jdZRxfVm}biq96$AE=###7_SVzSnl~Rxl%WcaA_obGG=I!_ zCwh|2cCo2d(b`ukfBWU^-;M1NH~pMlznNw9q(NY8Cdi419q`YVzQXJa8Nt@gb%W=k z6XC1_tpD!jkh@-2;FN!N+A@&BK@l$v{Bb2YNCctPW+)(Z5#Nb3^~m)AzYC1iwRCn_ zFO%N2l?1f!^=uNq2)@NE=(GS-ol4Msh}Q0tlNfCzHTAb~YM4bj^mW?^MGU=taxw>> zmetCeGQ6~eKct$s!5xR$orw0!dyDv7lvs-V9FzpuSgcrB%5EAkSD6Hlj^7^-iwX}5 z2ge)jGtTaVG!t8L73VbVtQM4SWhY&YObLI?@bw70(aHC7*)b(4a_FQd-192&x&=Q5 zhn9ZR`-b1;!uL8D6gs5%k_StLl9pwYzO#W3gql-;HirR;m`n&($55(FgtZ7CJ{@72Ar6Wno?IyaIbq?0$f+*|b07BDUIu-VCRw;veR2@bIrf-Z+-eNx zNy?8uI|uv%u0FH?Il#^#EDft)&>IHpyh*j96D8T=GJnj|Fe9a=>8-E%!Eta*~M6uC_`?W;^VY;X>qPZ=fgVz z*fl>=@N4VD=r_-kfy)l`*41lFZE`f%6L~J+1a_FR(rXeVo$e2A#s?S#R0)L<%Anl= z4C+psv9oeE+0=0Bf+`E)ngU6r>4nd?XU0l+uO?k?vkZW-2m*2poqsS~PUlvR(Cdf1 z`m8#r{i)UZJLgpowVXoJ+vWpbs*6pAr04gOx#CFk-Os~Oz7`iRj``*|JD>VdDL9jS zMO>C6G%XFcK%t%}NY|_5+9&YQfMyxVxD>y_+*gv{g}mw0>FT!6<$4DavPHRYC!Vle zyj?`?MkakmDo+!poWj6MbjipKC}I(paCcNq#)U*mvz4ws=v*G%y;gcZ<;8%(lwj_O zQ&iV_WZ`ql@HzB7FFYi$>$n<)*K?(|BJF|lU*h~Z8Y(4fFRA3~srHk`+)auMFbwB5?&_j-X-Ss0I7hq-a)-};c$K! z59!>8pch*$7lt3#-Fqo1WGGVDKW?-ZpJN@-!p7Y-3UYv`Ktdpo5zO;%d7HO=zx%nt z53!}I=2Rq`kF{&mGwjUOEwj0-q^q`y!K;9lF+{Eb%IpYQ>?dJ*#o8U|`zE20W1bPm ztmxC}w@P=_#=JwUyD#)>PQg4cIfm?TG&e0=#|4%2)fDwMiOa@0h$ zj&O8Rxw=EXf@j}*IWX_Z?U?;9f5wZKYIJtSx~2Z+mFsISD{^cmVF3b9x{LwF0En z7gmOmx{t@S3ExOM({jF>^gpdm8^$xg3q7jfQ{JzH$ zKi<2ExmOoO?v^{(M7T@%((jbnoL|LBD+o^!`6>u_8~5v_(&k=hG7xFF8Z~qsE2i< z1xsC;yXMqe;$@2YEK2tTdWMZG6Wj_gdae1KZ z5k;GqyhFFZ(u(b_b5NFK-R-|SVk(Bp%lFx&^)@cY*HTQ) zWGm}M_w5D2>xnyj-(z`VtHQ1C_)&h+k{Te`;xR(GACON)rvTmo=@(+gmQqsxhR?8+ ze7WS?A{m@aMsS9ACS^{o=nlom-3Nv9F zP|cpzuolQ|Ir{G(0bR;_xdE6;t0=_qrIYF4zsGgvN}gb-(5F-3&gHS)c=u+rvt0t) zC7PL_Ol$mSgbw`o!VC)^G0){)G620c-J7B0MLzQ)N257`tzM18a`zeMfIY zQVr(!XbkTJC-wxH3fsAQR#AtQd#V>3_Wx!$+r}jkpR=4^1>jF$$zQ`TM%m}T@*b>l zu^OQYH~y0Rb-QSYUHn=weL;zS_JjPpsy6T)WzmC%jLJQXmtsnjzD>yLIjPF5PI-Cn zdh~9WLUn~x*SWC1FuZZx#5hzo4h0O{f6lr6m@Hln>%DgV@iY1}QQPm*#$#~3HbUP; znTE53>UmutxF-!TL}gKcGNHZFlw6El7nAwlWjlFUuHDQGdxB6 z*}tT{SHo#J{6@;vxihiP-+XYQ_Ob|wy7F;Tv%f3WLo50q`=>rLw=VT*&BFbmVY|WJ zsSnGVJE<0BWq)~mHvXPr;kpFs8EE(r5bF0Nssl8Jl$A-RVlmw-iK`J!PrujJD|dF% zOhs(irb_rmaQ(7v1vG{N`Y_`Hj-Xo-54u;792Iy>2Y>tPPTya5^4iBqioE{2&f@N> zbe=^xH-AjZ73oy8=(J;7vNimXIas#`&WG^$Uj*c9!jeAbZ@2bTS_L)v{XbSHhHAP! zt)VprD-Bu=Y4OblB2R={YVJjH@y%|JqOIS;wNhT^N36G*P0wkac8S;&6J)KkzeG(c zjB33_3Kd^QkDwub`)h}7N6?7q)MfIDa*Z|l;`x>PUaL+FHLknj_B(DVw)v$!&McG6 zCfEmSJ+~(JhLks)h3lNt_Z;hEu}x%>>&q5_pK~nFNk%v@Lc{|Ui3hm#3@?m|GKdZ9 z$MJ~NRq=8)96Kh`pPs4Ss=kXp70=AzGLX@*!xia8NG_ts+~)F zy-CGhY^~^n>$UAPX%fv1w!rZO!!XcM+E_5gO$f)niR(xuF~%Ncc{Nac+o6R)FNa`M z(JkKWOjl4gAG{+4Q2q#KNOC0=`fB_yOGelo_g9{Wz8ary_!@;`3rW<|^9p#UD^)1S zY_q=FB~Lk_SlhqLfx#rYJa)Nsyhm%*r0iVPZ4;gx7M6aPS@M4f`^u;)*DYL9Nl9VR zpma%xN~fTN5;h77l8TC;ARr~uE#2MHDWQTOsZ!FQv?w7VAa}z0Se$dlz2o}Bz4sV< zj_+M>%=yfE=EO-cyQaaoc1M_@2Hi?X`S*GP25@wBso2!K;HqH8#fhq4~(U9Jv%=Bwd9Ma_(SQNr$EL{Hbz>5Q*&`UEy~PYvng88cYOP-6Iu)ggRVbYbC{SpR9vH2D z#t%U_Rxt0GNg(Ez-C49RiBT^C3uG ze8#{b!fo2=PDXF6 z-IaB2X0G!`sEtM< zLhN?zh29IdZ=c9A?&PfH03Ks#3k5u}uP5C)FmMUGb?|G)WA=INYH`+iPHAeUvd$CS zk(qYxpWb*}$#M+^IcPjXYTCD_F-1U$RU2Yi+N~6>sM)ok5+)-Ds;8;1oqHbPjBVaO zFA)pgv4{#V1fzdnMFnP^A|`iTUJwmw;E3Tmjvxn# zH-zG#W*q~2yhq8M6}iY3&$lP}{<^y0Qxs=6 zYI-@UG!)12qT6R~KDKQR&(<`)mlb$B9S7u~zy;aQ^&L!gCw4+($f>UxCCsJ&da%D` z5q=+!i2J#L%Vy6UqNS6xo(k0*&>?_Ey9*f@6{hIwpC1;?TFIL%^YAal;ONnp60uVm zd`~9p?uGvz8dHPMNyA`E^mb z7irCk{EDg4Y;D~w*O>miL-#@sJNb*}qh_gLGRAm%fpUb~xsq@HI7AZy$`uCdjlRyC5PL>Y-MIA|K76ey z_M1tq&$gCRo-pAM=u2B&AgOGn#S?hE%L*|_C1J#Ah+n`w^YX1F(W+ei=rF&pWM-PL z2;x~eG6trCN0P_m{er3;pgs@+WATgNmayC(Lpfc&-AdhRHuj zXV+F4=D4e{MZ}H}5zLyXx{d7UDqF3495;OS_6YT{=JQ1}XZoSg3uw6y2!hgzF>>t5 zS2R}oTSNF2Dhxij)G}%=8=hZuV~x<)ey8rrb6*_fVDt~tjXmj$xhCg+-fF!Q948$R zF=Nw69!xAM_1Q+o?g(-EhT1?~#`-qMDN4b#hJCG)b?Ed7UKJRvuigb}ZS!KMBHiap zR|iQ)J_OT+2j@np(|+gxIcPUW@;hVA=D1;D`KKu#4xm}svcY5{Z47&9)n4nEsm z`0~#YYx=8oFYZTG&%d=D4EmWrPRZnqbpu+5v=*Ws@*5})o{{hT#U{f5X$^t4un^TL z&i5nZEc|&MOz+$!e%ZTe4&T_TsyLV^*o_P)fMZZ%e@wC}v%`>7u#kWIA>Z@q2b>yF zEn`EQIonj!fvk}EQGu?1L_7SLz#Kyl`=_8{(W1Y3Inr*Vt|~>J?(sxF%{s%i5$s)j zo|71e4}phJ8o6dshjoE|leZOUq^$m(Sc?xNeDsY!2j}!F(P4%OVMn6gw7i`BJ&+GU zc{HTR{7Z^X@xyVr5@4}K9wWzc#UsaoAvUZy=k~Jx4LW!@NMUH^J|ar-40&>Kc8V-D zLnS|xoHv`baj~iLQIbRZjkb%eMp$DUdJM1(do1|j4HW1-`}2e&sis=kJd z)R35iLQnLmRu&-LFqoPIG!8;{sHcQv>$2D$%jCW2KyY=1&innfwXQby9Va6EDABX^ zuGbH~C=n`ST{?neOq_D&W0IE@V~?wm8cED}S~fv#Nu~GeHo$JsbBzAt2vSP{2P=2- z2tSjhm8o5(EDN@=UR>0J>gk>*>95$WXXT=BgJt0d?&UtvW~LPx`3M^WH6bg;Kby&k zW3sg~bWUD$ORQl#dIpE2u3ol`lwBru4?cl&j(#V@$jBM^p4t6DmsjU}(@8gWr>qPp zyvy{ahMumiP*&l*!f#3F!v^>SCBKOJZ)(Np@gA$G$mc(CR&G(bXMPrT*Lz}UDplqi zyu&~)VQwv{2r*h=RcO>in~i?toxt~QyswUTdi9)4EBBYuC7HtV>x|T6VtAdep1T(i zyCxk6{V1X!c2ID;1HBxGxe;`YxokbYxSh8uc7EhXxC!wkCc=2WpeCh{lK~Nd345_c z;FCgE5p5u#3%2D9z0n23zXdUySxxVl@wS%f%Q*WiM3&nk7M&ZtIL(M5wg^Muks`Nk zsO?8;8+T-POlOLd&xVv+hIp+mES|rmXFkTV95Je1Rmwm#0c;4OK(~+7!KNepaPYlx zi_3rY-7*c$KCi}a*x-#>_>DV}&^yaV)a2UUU24DrIVEt~(c3Z+kNIBzPbkh$Zt4dP(%!HUB)0V$_?nP)YG2d3doFlx(p8iA7Ik_# zO32fUa|R{$fO#r7)LLiI63_+IoFO6TzcCmz^N=0y>**leJ1@;%iI0|XTP``+p6hEU zz{;j75n+v`Is;Z8IzW*9>_6nOO7={Q(%LN2_T<)gYQ2Jg^x-MV!3R=1%H$a-U4o@d z_8^>qX6~AK52*cIt>2To&uy2fc5+o`IZ-C`?`4 zHyd>&7&Ifc-i_ZBQys+?wOYLUbm=bfHUGk(_Ga6dtS!2ZtVvDiIT1t6M`MB}e2d9E zfr)GVr1=+2k2syY|D!WUy!keZ;wmd@n&VCc6#cys5HF)OWAf{V?$;?b>V)*nsayp^^eI4egr6B6xZVglZ3jLmgR%;%w(58=Y;c z$FR9CmfyFe6$0=ntpxqe=--ozcq?!})crOYkW%T+!(Jx$%?>5p^FBCVe&uooB38D{kzG@9ohRwPh&pjcLYWAr?}N_B6O z8-ArFzCV}Ta;IEI_LlzjK51wvQ-YiW!oT-x8sm)l^xX7&(@iL&9$u_OSkE*T6aCZi zuG$TsJhIaoD)-kRfmGky=ofb)ljTVJ4Z0tucf zXg-SiQ-85@`NVm9=dkC05(4}0zg*_tU8LA0T+!Yys|LoR`}hwM6w`F(QrdNbii#~rcmG8NOH_m4g0&7XTg(e z5M6-arU>G_b>w2sEs4SClW({=!}e8MuNGR>45Pb`TG^*mR}}?1eB4lPK`*NUeHT(z z^`{Z(Y{AApiHAkPj>1xu$EVQIVTF(g&R*z@9{#S!I>EXh9w|WsnD~EKbas!^e06CC5lVus*kpGtiugd?$0wPlY}*%;{<@R;7X) z%+6GWX_ot9(=b1f1xo*D0BOOW|1ALgj}Tf){*_BdN6%4^r`Lb#y%!qT9@g3FX!5f8 zro|Uc7Aha@gX_`6Q%5OBQ~AiC%XpNvQRb@TRlMthbuHi7UR?gX_~1eeSbOlj5cD1s zhq)ecmEPL z4DQ-r{=r`mS=(PZx~(^*ZV)?HyiVgCOC1jtewvj@Q@Mj;1kJ`#Rq^Ywsjemm`>lM9 zhcK+R=u7+Ur+$1{E(WpX^Q@owtN++A`O5G)-oXU}sUis+@B154Mpm*u80b=Qu2V%u)QC4MM&mUD@X;`yxXRHvO2gVXfx9*-!uQaKkC0xZm8f zkZxRTC|k#_qI=gIE4&BIAYz2P{kX$PR9w1SZbf)8%yi#JRh*BT(nOLB7QOJSjZ4g3 zND905#}jO=B9Qu`bw)mthXozAnO^>Z$~L7Qr4oYs16wezGv%?@o9zhHqMd9{m+eL- zyb%~&CXU{!ylUi){P$t~_kZotBkce1D)bL$6vA)9dHgrE|JyfQQS2RTE7!q`j&ZnO zABbCWO=?LToLR}!kD+Ei0?F{VcipE|@f;;%{i~XXa)r*^wrenQE>8mxB?_T@w6QB{ z$DCQl&BmQ6DQP1k2ct3rtcJ?xuhoV&&$-;S?of+renOVGr(`7$+T{l7$+1?uC~jkK7opKV|Jn%4jp|UIjgU(GYkQT0aNW?jzxNAz?XdawE}|^fM^0-5C6c*4 zIOj@d))Z^wEHm_Tnv~I9*xV`SPdKrbR2f_FhC+!C>N%tl@hq@GF$TuSG9= zb_dhd;MF(EGjHbVrZhhxCM}mTT}Xbb>QtwUp0lTuN}s)OA0#JXW)B*#*N>C_KNS?~ z{yFULcN^7SlW%ImMqATJ)LV*dX+EvBOZ_5jsOYsx{LrAz6UAL#jyd}ahySmS6MH7D zXM3&pB00mLaaDtBXuri>HJ=SO4xfK{H(z}R$89gojJ_}xZWxQ!8e7`L-g6(zYQxy; zl*6g?w|}A^e973xdGom!myGZWK4=F;NDiQ1`A?+y48Et`R;E!TsP@Ku95*FCl9lTQ z1#QOc%zc@SndljZqr{NK71^sHLnFd|7JTWJXBVzK}~WGc*!ao zy&ewda7lPF{u{{3-PWOkfubB?meOZ#hB-UNB-E^|%86@g!8-%94j{eZ_0WR!>_ z+t7|d2D?^{J7Uuxy~eEEf9ZJUylu7`5KHwI54vzgvN&Hj^()9hc{g$aGSV+ZzV{(N7pMaSx@S2y`-j_8|T^-fC*9uMie1l13qY@mgB|K1k7#yG&{R^hwN4d9c9Sta{&!xb3MizOi;VXY}z0%uB1S0#~! zag!yE>Ep-8S~x~k{y|6m0l@&yg}Imea;`{kE}Yv9#c@iUMUCF*ig?CgdM<+b=nOH9 zhH0%P)1aXjMC#8$u|QBBLGtZ~zwcV}Ox3qw?4KoB9ySVRUwBdBEQ;yZWweN2p^~n; z<^YBa#^N1x6aJaR+%MrYfhV}T7N&Q~7gQHGUwHQNw{zRYmpu2tXZ-5o_Z>V$D1nwj ztijM>6~mNfa%8tx8sn!){Jf9-f^_wYO=+ea88v~UZ@x$h;xK^z0AP)DJ${Tu?+YkE zgXUU7XJ+LaPdw{UV{P~2c^hwu2y(^cu1&WGC>5?X@97;$QDi?;5poESTM;C#czi)M zNat~U1}Vv-vbA^%9A~0P1#9(iQQTX;ivXx#asko@m3>$RROV-4)~mB_J!~OkYD}6& z;nAFx#If8_wL3xc{YcX=1o|X_Y!mS~ieX?8qG$@QuD1yu!#)+^=*mDmC{KmuT}XUg zz_jsGPEd+o`O%aB_shCChGs z_r?J+|L&X&IR3F%eBpeH;1w<_`}O1J*gvs90y&kv2-5zu%Z$UQ2meH->rXE!UDKu3 zsnUEEHbph|uu$^x%$4-!BJ4Zw7ofU90UFDZTI5wIu0b43j`fh%DNb#jizhU=cTZ4g zIBaX&5X)obre|^s_(hvl4sv@A75aN`V9X{WXUdmwGTgG@5u4}pMT(J_lRt{?M?QKc z&`Px1T9@@NYkAL%N*@p*G#<7BT#{8MR_K?&lKq%*KbkSnuM%tNS=bWpIDU}z>+u)t zP#mQQMO;Wct}h?+`xLl*l}xna3ucDKxPy6v3Z1eR%(PjqZ!D==m|dQ#5dt~L6(eBL z7X~LG>m=PM7plsaET=L0#Ao#LUE_O$R11Q*kkr%=P0>UY~dTd0@2S;3Nkl+@dr6^V4X$pOYk;EF7=ogD(h}fJ*hso z_U$Q;cULQ1UdPpts!cH04D9?P-wO}`b2O5#*sa8vt(~0T;nv6BmuC_VrFcE*7(^Y_ zp)(Acd-~btA%1stN+}dMNuvsSF*TFx8YV@x6;Fa1=}K9`@07UGE@s(Ym}m34N&2oP z`ZnX<`hZaa*~fq(%(?M}UD`fs`e$S$+M-(JyVE&uQq!f6Fa2n~XvLPF{8;1&*i#Hj z-O=Wt1?joldq0scodqfrNUckc2ePihczcrbhMpXI&TnDeuc)%g#dgC*-xzaA*BH24<=xZ`{6{ z78_`DS)KQUmF&-yfDO`|tHaHjve9Zymmb@J-wm~Ch*t5c##rU0lxxk>(?(ipR;QG7 zL`Q^!IbGGH3N|%l{g4WJn*``j zRT7-F{e7MD#-NDX0}6fLPMpCjZk4uJPGk0WF}BCz5DDK+{D;&1`tNZlP7&UpptCO* zoEIj)lK#dujt>kS$9W^=o&gTZGg%j>$%fVG5?!3XNBdjg|g8os`>kaWi7j8LV0 z@L9V}q{wWU+Fn4?s>{lV=1Z<0mZ*q47!%U7_p@3dr}%JCe*e=cvu zM{)Lgy~)Y!2+3>bPyv-7w^xyk-WT7)cv*yt_{+^%ovvuNpsUF;9&B7mR5uNb$!=7g zqRx}(npg)EvDZ0*Rxdq=X;g;9SL~f*qSwzld?o$&C*h3!pk=EZskw8ILZYFyZauWB zz(6qQPT$|pzC5&Af_26kI5GZkcTILkzk-8$+h8!qH>29jrGu@un$2#h_$>v(3t}*M z6)iU%i7DQ~Wy+osx$Nt;@%h@n$3E$?4&&Ce-69{#aXePv3pqC4rX+?bcQCI24Lb*y zF?#S9M;M`e7~6fSAyHL*`6qXzq-&3PTVq`m9rMUMa`G<(1)#)Q1c9rbk(h(HeKPN! z8sr+u$oe}hO?YleghcyF%5u?FR$Vb1SG?H?a6%ZW9nlJ-2j$&Lw2FxnAZS=;U{!(O-_^B#l#k_rQR~Mp>1cZ4LAleAWX()g2Zs7Cvv=t^`g_ONrsZmh`IY?(9wOPSU7~&Wy z>AJ##Xm+93@qN`V@9}k-JNLSrdqw`>N6}v%yo=14z)Y)v%Kd~Xx}7HUd3(`i$%^Z% z{uE8pspbaX_9)RK^!<(f%yysV3f90r>@j(w-RejnWI@hNHf2Db#3nmRmFC#76e}u| zcNSW`EbnLLTqfu?BF>)L>!|_oj{L5ga*UjsiG#b$Als+ajOEw#e?7upU(7sq4nM_S zESc<1`@>;hkdubd4(RWdLeVnnErD;!F?v~oHewtVa-H!a-8_@?&AVUvj%9iG&>2aAqTlyt_8(mP z;X}paliBfd#Tv5t(K7Kgo3Q)dwf>Jme1;MN_bRHeJoNn-KV*aW*3H># zU7u9;W^&NszR{l&LS-);O0LsBuRdj!@#9qVfq{Slk;v$bfY0dtfODQC&%AOYK&><5 z{=J_9!^1qj^K=gDK6kNY3q%GKms+5FM->=j5YD=A=+)TUe~@!xKh~ALYCXc{ZOC+O zGk4_7!pVhXriRy9zUgR$5@p!FqE^k9^OAdWm((*0ma(*9!8dukbu zq0CGIW!Kt%Z7g>ukZkpKB(;_lV>6n{QAB7Rpqhut)_I>>8mU~Wbn57o1OK)CpjM$_ zVzbrdh`z(yM_LPX>3f5a_rDnwh*|42sk5H+8B$C9W8pvKe0$i>3PHR-s<;t2zrk2C~iT#07&1UzIuO+m0e`$NYj4? zlwnKv{-C#be{<0{Aw8^3qTu$*Pv)O_U8X@fvc{=NpEyo&UN*||br{Kap*gq-Nt3_M z&Ty=9aFpv+&t3UM$M5ohoJ&6Wk9hRs(s<6zY`_`{Kp29UoFt6xC(GGjOZrZBAwN|* z5}&nK_qfq=u>op9`nQR_*4VebT&K7q(2JwxJ{KSR@0+m4k-NXx$o(?X^a{m7K8;8G zFITfk=mhB%+jVaZ^fry*1Sm8Z`wZC1yzL>?{)>6IBZ7+Ll?!5hrr=&#^_hr^yEqZtHDNf4u)wKe%{?mXtIv(C{B70iufzTPMCyg_Z{Bv%ke!dN=y)1_7hMtc<})FNUh*KV z$=Hq(0Dj`a|K5~yoHZjbI3{rkQqV}740 z{i?Cek*b-&(i|H01Ckf9P?YB+zVf?SR-%C~l-gBPcUefhbb0=B( zch7ZwRNDK@U9#?({MGRLP*4Q+6@6XWks&sq1;{(pdhFUHM+byl7HJmN%+LGt%nR56 zPe0N8TgiEvYIsY)(tyB*051$op-kIc_4faS|EIaNTzb_H_wOxf57J2=Kzc8S0D!kA_#p&!(l6L z=G#HvFndbFmXT1qXoGWV3BMe&wxy!i*!4T!EaGf80n7w0Q{-B29L|f=lhkww#iGho zJ8G3qmqnSE0yuy~y9n^t?pw)IQch-#|NV%? zbp1i~hlXry#D<8phb52`}Zx9rU#=9W2p;d9?wH{o|u_7*!LTeF3>r-Dj2+TRsm0@ z?*$}Bq(OxuQ8Kp*OzmDKueK^~0P^9BCz# zUkJtx9u7+Wt>V0*-CZ(zQaIiHbRuz-34ffX{`*(En%0B0U*S8-!UyT<`6^8CZ)fxR zT!>Ospi`B%zgz}GNf;;1B2ONPFsWza&A(b#Z$XwA%1h9@t!DS2>-l&mZ)l2oBSx`3Mr(S;X#etPf>o@V%Q7@TqsyhH- z_J-~uPIA#W<`VO+D_@k(&8Ph1xoG%1~;9IJ;>; zbc@7Ro^A14hlP)p>0SEEc8mB;-EV!9VJ7j`@46dY-Q{BTTo7A=9YqkeXp@O zNiwgI;#qCY7yV2bek)p+uV-zH(Sw|X2uz7Vziq@vhVRLDj{kaKIvF0Cq&7Tgt2hv8 zXmIjOTsd}T;`?2BmqJ^Rg9s3Uma-3Pf{p~!C(K=%QZp~GR`=$T%Bg&{e0fmu-}USd z@s?fn3|4y(TKHi4+*StWme^5eq@M`PnZrrY@d#KXznty)fFb{GLBDgINmmT9of=U2 zKp{1HTl}XGmM2y>Wi~8U9e^#^Vo)`K4Ox8bO!#Y=oE+~6Hkun0-Gh|=fvQ!Bz!*!c z<-(8iySk)LuV1+ZBVzQ9ehL3xJi|_Xa2w9qwai+!oTj<{*Oy~lal?FT(NQjkXxb8+ zR+iq4eHtt-ZG4JFi&GGg$_hcMsmSnyMYq?cnmS%QPaVnm)i~=f--?eI`Rp@$u zc@>+{x!K%3I_nni@-9Vs4^`|rRcM9d-h%Ohd#b5jABCHrdO9QSzN2UuMqpE!yjJ4U zvdp^?@1uYV{H`L(sD%lP7kq`OO~UTJ9FeOxCj)B~%d^=w(@*VM-!jIDwcc1qU|#_% z4b_TBn57DuArLQ&gS&kR-}AB}mGI8XPcL7IiFrKc6N{k#srW=Bu5?sI6y%`)9igE9 z3fy{#T;tbX=6g%xCIvjk51;2u)M-1$^AJ$Uq`xiTv>jDBUkq~6q6g9RhzX3`bH5`? z*Sz>%zVTcTX*@G4+ZJ4(VkJy7FsVo;M0Pfh3Bp!T&5gW~>BGteji=+mS!=p~>o0y= zdM0SnB>74=Ar~*?-*TVoJHyrokkt@_4rL@dlU{(i(}|H=(O%xX-n#tK_Hwioj*n*P zvi?39lA`5f(Hhu^cmi^YqA&?-Uv|02l3nSLRqn%?MGo=7Zx zS(e%Y+$>Nx&;_$E7wm~q9M^lW3P-;b|9gA~=jl>c?Aj>KiGiU%QY$}W{>d08(5Fy31ierDpKBk( zgyNSRr1AJ9?#&5uEi>TSObMQ5UYu1c!7q$3{zk#;-U}@z5_^~cz07cgsSqwRg}?O$ zDaP;j+=6ptuGkLB=~F!!q;@KgnmYAqxYN;x8!!kUGX&G+L}1=df8-nHnv+}qL@1Nz zwY)a}dcW)KKIPmJv@-Mf^D82~IG7xuDutYRWhlmaN-Q;N;z_vpzP-?Fc(l^}xU(x$ z+>LwdkN!RI8SN~jg$RKZkl`bQiXK~-{-saq>%@QFN=PubT+zNabc>boMnX3BfJf0 zP>=@VYNVob?2y~&aS}s#se*f#(FsOskF5!D+VGlryJ424-3B)as-uHqAP1D!h~N4R zG#7#(`6}|+RW1DcoIhQg*16lA&}TZ#|5ROx+xUdBVBWXbk07T26SmO^xwQ`?mvDjW zOb)pN4NtzpX*0H)GA+vr&eTJRv-9V zUtS(fR3#xMCr#`@>!9J8Z1x}*8~~`hIrx1oNJA3riw})k=1ASjtX24971!(ep)n_3 zxo^{yHFn<0OaJ|zZ3e&vgtn2y($@_PxX6gSlFWl5Al$x!d+eN8bjhQYB~hNhzp_tV zA`7OPW+AT*;0Gc+`?oW$10&ZQsKTESn{P9BwoY+Uo9v$~c9MNV#)~@53)LqWd8uB4 z98fnQYy?Y(m9CTY#tk+feUsSa@Yzed6~it^x=yNVQaq{`RDllCD@o+wMVb&>0AD zraFJ0dpv`1%$bS*Ep5RWyfc?Nb(7mV6e=Eu;minCL`k#c6P!NK{inI;(;hmy6Lx+d z38%rwO;!)<7`Qfp@9-_5HOruk3_|)4c>qARf3Q6W+ZCvf)0f4rFnN|*;#qsVzD&_> zc~oAMLFyFFPo;O*(iSAOJs=0nc1UN`8dC5Aa+PPQM#ew;>aN5mThXoDQTHJJ*4=)( z)s9NfT)xbJ8Q`A~lVxY`2OJsU;O1CLiaV~jnL28YZznMa$o-G$?h-_OQjZ{ zSo`#J%#gFjc>xa_H9S?Mu5Y!V1)l>3J|ym)29vq=rgy?~Rx7%FMyGZ8<>QxOKQG4J z9(;AD;3ZyIh;+}}f2~W2SB_E=h#r*Je@(=AB#bSJeXZBsN%t$BhSVHhqV||w0BHat&dRERajKbZY=+fc# z`})FHAp5$1Lkf{;d$6{)=PPfhbmH#6vrc}X_k4|Jewmyv{#i!0_l9_X`s@cvu+|VN zLT*;$4rc4`iOiCkyeTZQYRT#Q!c=EGX=I%5;V2sa08 zk2yo$@GJVW)e+WA3Ic|ZD8n3-)Htc!gk{5dh0>}jFK9u6xhcp?{P_c8m^dbH{UvQ& zO8-bT?5F5VwG|!8^Jh+?RjwpB`0M$^dw^BpdPpL6H!lgJfv@sTGd(2W7;tr#`Q}+1 zA1Id8ttm8XL!Nno>sJ@2{b!I<7K75J{cYLk!MuFnk;0D)EWA!6SX-9sT=eVY zTvh_p5B~q2CHfx+d%eexgSHgEkxCrc&idM^Yg2IohGAsOlBNA;l@)_%bLKMY{G}FZ z)<1X;yMmlFq+rkwb)y2)`7Qr)m&ee3G4Pz0YoNw;9IZOOXZJMJMV&v-ZO~o5L8e7X zEGfL#`HlYI9xoE&w~AOPl#okG)&HI!ZL{cfUV0)(pO?fTqAI2|S@@nSQxIBfMNz%~ zm=E^9r0#r7qw&R{i#n%K$y+8%8_~+YRa^_-fxYcF>I2AU*!y6_)^>2 zm5gIZ1SQ92tS=U9)@xj=zW&-<5ag7hOdI_@D0DpdSy_3<3W|SoIXh)Zt9dCu4s*Y? zo%HQ@Ql^4?iX)eFXgVd1lql-O0tSqu9z5*L);R5af4=or8u4`Z3wptr-t~8vlbx9< zyH#E*?4{_SgBqRl+^)uyVwgQ#_Uv@-{`R!nMS*`_``SF6h2@i{*M=ghEM?ZT-{L_K zLC{F`q^J60SN#vHqv7gK8d+c z!A6UJj^>YwIKCXq-x`0Vap&?A&8t(h3m$Vr8%C)PP*Dkv-a(3V1IZ%5qt1EyBqrWL zTEk1iqeFc3ja%5y5 zVfV?@YM^-bMfZsBjZ+ZnR8RqhfPOFD2%kO3xs}{1QEdttUrBqm8gEx7{!!ZmqP3 zJRm5GelCrN%-4{DR5aC|z#i9LF>tXSjl9>?-jZyN*hPz0Vz^nIKK zI<`F(4(lY1aYMbFQlz}(!!;V8H=Iy$?zqwdEJ;{V^ zb@IY=!^|jO-bd8#<7B!CJ^hj42YYx05Hs3}y*X?XxO{2l0i8YPhjW&czDZ(7A7nJJ z#ieVlbLTy!bkwXQlG)36KvM@=t^;8ufdi_`@~C=riHWw$eLG-nx+tCS&5g`A8F@D1 z%${~c$5|o$B&-abpXldR2nCJE^^@gKk0FwB3v0$HTVDARI&5%3DLUG%3ExmghwfJ(i`*CHx>~b)8t_hd?^$W!c|ad*0t_WV z*6C)+@7TfZ+7#rK_92<1qw=26jJEpR5A2u!LKfsSYPa@$ai}Cf@5^okMhyhu_6_y% zym;~6?TD#L{)F0@qU&Tj=L;P+v#4CB42jf14hW@?{R~3}Z^JrqiR%B5H@(LRv2_u_ zQ8Ue<>D5;}og$JbyF<0H>K(HJascFzkW$NU%sQz*XLJ@kXuW^`ii@KelPCTU3yp~L zYpvztaSE5Tbtw)e;7t2 zIA(oxV?Yk_IY@Z3KLi5+jm;M(=k=@``$Y8}*&piren}Ke7S@@S^n7__;&J&J8F>FN z6#>1S!@tl&SKxCdUO3;3Ru@*^yoq}4cjQbM2j7oZb~HmN+u9i=`0LE(Af_U55KM)M zKFBGY-LSDJZqtd}!1EKSdE+a#J?Y{9@d6)N=t;ka1e;2C0Te(S>!5z`Kk|Qp4PMX0 z5|?^{o}7DqHH^hjKjwMr3%wGJ$j1A-yaqI2JcUIMrf7@-jSTX=Y&_dr6tOr?CZoDr zQHqg156ACV&pErh3aClAT%O3Y2RRttiFomaofsn}>u1c}Ycnc&{X!p$*ZqpjtyPgB zJyDmG#`X$2zSrJaAO|!g$T|zFFt_u3rt^ysQhCn{u8!%7MuGyNH>AFc@umiqHN^j8 zM&-flgQ`nmq>;_b9V2(Ej`-PKfz7QaE?XA!Ugz_#3AMz&5jK2uGKW$$Ey!XIRP3em z(fPk*q%0eb;d=hdULn0yW6{2j8D%TV))I@Ow3GQy<*CN38%biBw7}Ry`yoH(Xg9_E;mqb+@BPj`_r4ZBG{Sx!5#@0!QIF##X7D~%PznQ6w z_48?aOcf3!GUD+((F~OZp9{z@fP`~j>8}-FuppmwP*5Q!=rJCH5>X=Z%ZKjdJ~64hAkR?6^6)F@Mhf zI1i=}G6M)C=@>`9Ie4p=@_FM3WZETWBQklFs_(U};D0Bq9*)ZGzZz0mL#_((JxJ$> zBfqaA2P4OHkJC3iZM2hRrt8IpW&+iQx*9B%(Po>r5s#n8wis{iIq%TjiZ}*f(5_A~*`J}I zJ+drtmE+@;z~!gBv2>wqoo>D|iKF^zrywz-tc?2j2hAM=KkK6HLz4;`(e2J!m#v&u z?M9DDF7fE!_F}&(qzXya1owRXy_#dR&7J>(Q9)kB*LBi!QwV-n#2-1r@@ke@@Lj%c zLn3dUSKt(`K_xZFL7O%b16e)nc~Q;iqLrIf3ypP&rX~?btx3O+H4BcDxei$siiDo+ z+aRY3M4ISJ{Gklv6jsq_k_;ao3odwKyQ6%Hz&x|xxlpC>w6p4}^Rl5LV=*NGaF(EV zqkac9EZT3_ka46L4wx&*j)b*J`2|B%gOZBl?#iuj5Dt>y3s(1cM zF8>0I5Rd^t!{(1jr95mh{iheje{N7;?z*fItsg=sBp4~kGF|XCaOT^;eA@{j2e8x9 zaCOkjpZtWmt4{9*Zu%Tg9M8q751q zmV*~B_C7-N8}!1L^)lG#OTUnx7atDgqTi{@;=gNnF1>yaPbh=gL~n8jQt=M!?9K16 zJzth|Em-jJ@C7H~4{y2V-Y8Jk){8cENWcHgH3M?sZ6dMu6zFV4G^o3PN1)SOb*1wV zcIr>17_0z+>I`+QV@gSeEb|KVi3@-WV88-m|5_u^njXHV_j`F{wDfvD{%n(PuzjeW zUFp?U-rFYpm#!IRnY@YzI17yj!oujcv6+r}8xK$hgwJU7lOj`PJqnAl!%E&caBHqQ7l{n|piYbW@y9#x0Sgd|}mT?kRD`$opG5UvwS# zya8XrY%Q?^ZvQsSn=+HvoLy-5%2UG1pgJe=Y$#&s_xY>Cox-%Z{)?BaGPfYKAcpez zC$PUA@U!YauN3pnubI_+th;6X-n;-yKK%(@l)#A3vpeHLZ5=?`3(hxa_-wzl99sZM>lOO%+0jX)AwyHgFT~i)%K#IEr~(ilpjBbOFU&Tk+|qa$ z`UX4Tm4sBNjn9CLBWnA5QG)8{v&X)_dDuV?6~SUKL;%^wHe{AFtg~UH)ktsgs@^fx zCX{dUqIb`8%^xLygD>%%kNrX)#RlFc`1+zq2mL@JMx_l?pC?oseK)13bQJOHejp#SG z&Y60O?e6S$drBN}VboSQIui!hI5F`_#5Bi(RqXoNq^TAET(h{m2B} zvIAU!uo~ihZ1`bl(~6n~!Y+TS9g%Ba-MW0i?Bs2(d!BQJArXdQjL&ovEdZv%(Aa~0 zEc%WKwp3;RsiYY6SInn6%4B@;`E5Qex%?f9(-d|6pPIp7mw}8NskbZ#RJC{9u>CRxyAYxZ z>D(^Sw(!+{O>s^&HChoX1M9JCU_lx)qaVnrN(muh`8Fi81>3@Xe7reb!^t!u$<$x~ zw>9}G`36Z#D0Ri>Q8|>BLAeRob8vAHyb^HO4kpgblAshM*I)md>D+^Q$I7Tl|^5s`y=FjZ@Um}3CWo;h2CTGHnTike9Jo!o$9BD9SywIfwWCQkUAd(lY**`!ca*IBV|;crBM7Rdndo z?K|-Y6(uhZiEu1NI<&X1JPWi+%zJsF zHvKMgdideSwW|Zt*1|kDU#Ocu2^lHdLp)H^v#&M#BQV?PWUpbL*=MKfc5hnVvD?pW zK;Kp3sp>^{%8p^f7rCF};B$Kj5}j3fjnFN@=LBY1+&32%W;zyIpQ3kgch)Qzi;Y>(nCjKSwrBt#J(F=z^7 z6eM+>ncnI1DhiGq_bz{qYZr>sd_hQvaOKkjX#owNJb4IiKx_kP=B_(b?)_Iy8`W$A zy~r|se&q|B-_n!M`FDyqpZoKPv0oy)S&SeDCP4&!tA8HmPKFIaYF~5_eIylXw54q8 z`5~`PY9<=pd_HDi!It}{7T|aQXa_7*;SefCybP?zWTA`Y)yK_l=_~(^xG=wHV?D}! zUQkYYeO#e&7wAb+NmVnkwf-H&ht# zHuG-@cVibf-eoxyefg8XCR{Ek>q}~R1ii)= zy#_X0`>?Dwb}$2Cdt>>~&w9Ea^E@r&=B3_Vwb6H7EzVI8lw02Xy4?Pq)JG>?gWR%o zyc=Tfk_zC=qpf$&A{h}KESwxovEYhX^ZtU-?9Q1t>|XL+G3&9r6n&om=H(RP;>lB4 z22X#ko$AHw=NrvG0MA!@MC51h{mLwSXZj_3yB9SC;!Jc=8SHGI#C4kio8=G2}N(T z{C`j=U>1F_(bedUe$F27mnV5?_i?>yw=!=~e+|v_e1|`WNK)sWAi86x4srmVyKkPX zPJY~Qbdq}*`Z}Iw_N?i0Bq_w)-)G)A9K(C#rJPS|HA^gi!7EdQ53`?p`)3|Vg6rGwbsr&b&!0V?H0<$Haqo+uN0a*1+?4{taodpPJ+j z2nfWVG+C^^?QXA&>YQ8zNDsrvkSfq+WKI+q8>2V&%e>Fr$)chN$L5tyLU3L@8e>6? zq}t7AuXfk1u7Mn!72$KX+*0lSZ8}%Te+gA@_YSze@m^NrjaU}=II5`V zY{rBCU++9yw3kq4nM0pRvEqj#GoSbr{{-$bdcXUFd+x-OxJgPJF)`G?R{8^NW!A*M z;g(a(eWI1nIGXguqxm3_&@IaRpO5NEH;i+SLFf_cOofnj{fNS7E9-RyK@_v-n&P$Z z7A;n6=k$~_<#lN&-H4qY{8j%NNDgu^b{zpBb8#5C$*Wy|SIcQWoqE-8@Q5kq(wr0h zvxhYPj74^jy@DG}A>k?^2GrkZFu#CUceodynMzLuPxWi&m~ zIF8IMkKpU=Wh8;I2gx9{WA23x-qp8GOj*jembfK*r!M%F36#x_=CaV}j{RZ!Ggc+H zKk4Ib47xlRzB7?lRPcxMj{0pyor~WSteH;w&X)CrtH!172IW^D*+>8_3^9MCmd70# z!3%OcY)UGuvRm4{k;OeM3^w?A-TECK+Y+=YI~(U1S)UMt9E58S&XC1aj21oa{>1hz zwvVEwSeDpB$!=?^a|(yliHh=+hN0^+|SO$YG3Gb7J~TX+9%tFw{I zmj^y$W*#l>o(UYwF36sD8~7W$2mX~|?m61b4ew&Ux5#oyu?t%&jk*o1vdCK~{$`XPuqQH5B73=3f;dj{i|86#TfQDZYbgP5=G70zIx%yvy55uS4&4w(L0@(gzi4 zyWyDM7k0V!_XWSTYmt+ZohbLZKamDb7xEPp^M|msYUY5afhmkO^8}{hYv@ljXHBUwPa=J#|@{d_Mg$PT~qLRNIJ%{c%J; zX(rvvr-J4|5&9QHnE0GQn(08aeIj+$tKW0c8Q!70?lnOwN4$SBklr}XcailvJV##g zV7_|YVJ4LIt(|l~C+Bnbgo1n5e)qi-Ws~#iXBMjRd}AqaL;U7`W>Qfc>L^hAF>pBO zDsW6)tL98?E<=;8pq%Bk0^BMbNz2HE&gb(#IVWnGAa(%*(S#AFbUY2SAGdy8(LMQT zo94G9J6(OAT445a%MgE*r{uhm>{;iy?@)1|0PF=w8EH6Djt}2057)7kMthxl^zN@K zskB+M)Tb+-6t6byEqqdlevCZ<`br7t29d6a@4#h)ghwxm$u7P(kkj%?y7=v!h%3RA z=A$%kuM;N(SlxDUkKcI*Xd1|!k*Mk`j9Tq}-$wL)VfO2;@>RrX{E-s33rcO_WPxBBPPzFyAiNrM{ zbLn7PEE>tB&XxAfn|yH!d}MQrKjjQ;5YMpMuM~P1X zcsO~4Y`?RNkcEbU0-qHNOCBFepD6_0v9Rpq+*CbK=%E?~ebTJ`@U&axwlpb@CTM$5fHI9cI&9LWVo#_)=cJem9;WSL)G_r%otU5D`# zQ#;Rv$4yk*BVg@e${Ny2J_yltB=l6P%h$+$`&(tautkF|PgU+{V0OJzZUVPr zP?D3#@%F3Jth!l0^shLDvWzYz#nXu*&6409 z9Z49?uu^?J77y_`O6u-7VvyTsJVT>|ZKU}Kp4TzYzD}f_=WdnuWAssZPs>(c`bVdf zGx%Y8IezK^NqK-0fd2_egy$V5gH&;}UGEi!(HT5ocX64=e*cajc6vNOW#Sjv+2b>L zOuYN(LI?(epsiFd=6gA)bH*_>dBQSf>$(0Zp`l#oSppVqc0{CDnLc)5i)<-Vgh-Lo(d+VNe1vD?z9b{k*DA znCGzx$+|o`=D@qkys&=h=^WOd*8Fq5BD%MmTfdt;xzDs8(v$}ZIrP4aBOJ(ZZz3HH z-T&5!61;ohR^o(}m}z4{%45W=h4uF~Zs9);mRvv!5NSf%kURs>)&tg=`NDze;>Jrq zrVm=Ic~X@R@;ZK}SXhXjc-@T6H$z@(3v$rZ}%c(zb7(G{?_#()NwB9+V>qjpJ4sCG{KL~Qu_K9Z@z;MsQ?8KNJUKg zD(3qs)%hf^YI;PtauTHzc|W~J^SrikxBK1Sz2w(~e-id4K@MWXNO|M@SB%`(&!m@I zZysqoQQZ=~$iNk~Ku*zmT~e&}=d436xmn;5kb}}@wWtzL_gV%8j&nVzz?TM%M|`f}u)twWs`q8GN8-V0S;n_~E7!ceDzAK*XS zWn_`}B?QZm+@dTkz&i)Bl|uBNVllljG!6AxUrD#<<}W32=6o35Fev_J^Y+L5hG@lS zUn@30Yd{MCGLXWK&|J*=tS{2lM8|kGD{irR?y$F>dYWf_t=2n)MLB0TL?mw<(4jI^ zZ6f+%0=UPK_096~;zrJTBu9~I<=8U~FwGm`3NldsQq43oCdPji;R2KhD)dEvSr1T& z+PiX6r&;~_+Ip3|A9elby`Rwfb$L_E+sDqeFs4UvL4TFv0d;j#0vVbCa-Ufrix>-! z5=Rc2tgw~v@bFnE-3alp!Fp>!x7B~zZBOy)E2)I?vw9*z)V2*L;zUgUi-F ze=7g=`QY6Av&X&E(dU7cXVcZy{{GUJboG;j4+rmbJ^%Y7EaI7&K6sBRFv$RohSv{6 z#W_9ys7Xxqeo5ZCY91EM;^=*Rl`c`<(1ra5p>2kMsndSYP~spI9-fahi2W}e?r5{^ zhWZ1w{!BFP_} zbqrt=DeUw95BfDwt3?Nh(s#$I^2KBF2^+$LFU_1}roo*V{=Mv<>Se{IORGP{ez4nH zLN=9ODz!iKby}K)R&<|Y8#}Gm`C^`4TG)4r=8DRnua}(x&xoqQyE%>-~!;XCaEI|wg zEm!gZ;~74g(I8f|rRexEdrpqB*u=u!y=2s)P9bNzY}GV4{9GttBtVXs+DA-&Kuxl) zBhe?kPqJvyYZTwe;*pEhgl|0$V?#f+3Hf*y*g&YX6hdl-y&^CeDLU*ohhjHLU&Few zNLG%9yH0{s_S}2heBOTD_>e4V4v4@g(Qgi6Fb{Fe?IPv#g#t|tcRhMNk{-A*R!tWd zQ&jd*64M71g?YepV3sjbthOD1iO}uxr?()m-Sh-|G7=gxOr% zyk!|qs}MA>qiuUhCgyHUzRd9WGuh-gjHhbY>1MCPν>PP1s0_e2*fv>qoFG zqI*AeVm$hP5k;#1)TwnEo{RF+Nn=MohH2OEuD8WEl= zuqmwJTsM1k{Z5|h+aae{)$LHUZYG|b43v)Fh+q2qJY53h6!r_3P~SW7Jtp!KK__In zCEeW@5_@vifb|_`%n#wgufy%~hF32)tuE?1f*hpfkUY|A4(7X!m9>}P9^Y=GYZVs% zlWTD{y7OG>#$P$HtcYWF(_zBjKzBg*2a*kMJv?9S*fd*K+w_YySMDv$@(bNuBH>Z~ zA+t#kdFG9u*Vi{t(E`I84yxnEk>|nt<#LXv$Kt;zd@4o6PNq<2dY)RwXRz7-^Wgjh zck!h^&}b+Q0|AhTj3+Xr3*?k=ZxJ(S#429@DP}JsAay_ETGS;L*M7p`k@?YQEKRY1 zc?4n35L!1D=3u_V34i@yHuAR?FW>)~`Ae08OV7XgVlsv2S)TT@P+oHt29Og4RzmcC z{#wGg%rNUMg0rN1P8^%uwC}0Q@!q#M_dj(o$7N?#Ddi>gML}c*qSy%L_dV=ZTMv&Q zY;BHMInLbkVo)*K>#iI_pmc9YahQG$Rl9B?z}8>2yCR3PEhfQ=!ZPmCI*uL z>nvxh^zyCHgQw*h^+H9P3-SZFLNNG>ybl`)dz#1bFZYj*XGYy#hH1R3Vr( z37Ojg&wFC=;Kscl>N7;D+k82N9ZRNcY&wlsuSquYKl)?tbqpe7FuV2O{>5xytW1KI zPB+09<>8Z@y4D_w)H>2H!+&{MUdcNbA~+zV_5#w)N)WgZLf`k1KbUo%9qqqY!%1H@ z^!#FhsRyrUdA&oliLpzF;AVuL2a)k-klP=4fc71NkcbYflMvU6eZW9X*Q8tFmE`p$ z`WNR`*Nxc&OAN*)$%A7CvdWeJ$!jk>oXh|dA%`m4)2-s~04=zI70(jtOBEKT{Z zEUO(2%Ny<$B~_k^H3y6a5mAIrExQ`+cdpL4jJ_r2oRUMXP$U zLHs|yqqQIhJzL0quQ-hK`s=4rNN?hwB+k57*(>y9^!3ZAdp|ZV50q#<8Q|DV)%I@b`8TDYlr>)Ms5?ANH_8jD3$S8wcm_wHcMuQ#4<(qrPA2D3ZPLx?ZdGj?VJIJr0d&$@QhK9!pl+ z?m8*dN}wOo9dT5~3)`mb)^@{?>v6b`D&Xs)@qrJNt0KPAj~dmmTpFIVU{aF@4?nOT zcOEH@O5(opNbBlv`5=>)GPoa*c|z=3UJC_!*e4;D8wNf7_urtFjwW8uSn*}H^C%L? zBAuvK^_$a3z5e;nmbF%1T~%w6MV8n4L8cJTpV0GZ<+ZUo<2CHg75>&175Ck*w=IJC zMN9jLEtGnoTL^OX=o=IN0psO4mkT}0Vy+`w->mY~=+W0~WnFw|{oCfKwsv6?iMIuO zG8h~uf1~Io@!K_$pG%!tIChf-T~2J`VCObf&t3rWO%|W_k3D9Y>-W zaMZT#Kjf^vDca+eW0X4edv=WZ4QbD|q0k=B{f++(9BH9v#wvnMT$;g5+ z2~N~LqbG1=#0YqgR_Pu+^Qn08Y~<6dLV-MUm43&Y0a=bba`WOX2MZSXYok)5TcYFW zJm?e~re@_HMrPy3RKB1mkbw77{3j$CCB-G6^aiD3ULEG_X-xXNQt-vc+K1e1buJ1- z3L7L(8lA}aHS=LgKV~KyAQPCDgUMCR38cg)VWVkbwDJGgWB3)d>fb1*CL@;jzJ78e z@0Iaat7YRg6-GqMljF)9t_+kjO!T+ik`E4c+L=X}RmIUsN-;Tp9F^kK2`cU(T5dh* z+X1&q-Z^3`z|-Y{Hy6FlvrsRD^Z-WZhYYbyg|xqYXR54qel~_=epZ10Waq`kHj4DC zH*k`vh!h}`g3iG7#9(mViq!YOuas}nO4S4XP8O`aTfMj4pH`cv8C%M*pza+Ebuo&{ za2?S0z9JSGe*s^I@E`~M-*1h29RHc{v{@{ zF^O)a{fqU%8z+w|HFX^o4Eg0GG%Bf?N8$bK&%;p>pL-s(YK>mgTl?Wx=uSbBN0VC^ z6+2(+^PvQ%bD8#YHty|z^XdXo#nm6I5@fcFIz)NbBiuo5f1nw9=`e}v;9PuLz8WL^ z>aLe$*xgEoYm23ZPT_Y~D~BGodBnA>gdTYaa$qBo0~vfsK%N`$t+AoEHzXn~pg~=G zw*&9kgwn$)@&05c$|nBIXn;6^P_l#+h6Y7qOr(-+pW~G~T?H!7_RBj$Ed1YEz_$r$^Ov;_Mbb>i?DHiE1X@Ca?$t_W_ogH z51SmI*gm5LQt0WkjxpuIR9IQ$ zfMO~C6-L42FG|xF%d`ZfN0A;^bRwDD?PBQE-fll~{-<KRbsA}T<6iFRziB1aaW1FlG-Z=3Y|T3)JR z;KJ!IcN&t;8zy1j&i+W@<5{lO58)?ZJ~}ASoyfv`hj``Au4j_mo6l>lm0qb8HREjT zun9PwC`sYI(alkP))D6K-T^II>*#anTqbYj0S=8?s_?q>b%Cqd+m_i;ik@ofoO z+6@LYArbq~9e4`RH}VCLEg}1I!=D%T4KDAb0O3~)wol}{HY(+7H7)T$D>o?oSPKRD zK@QsS5vaMjhOx1y72Ct)RTl)8iI}d;|pNE@5jNi zYv1Y@A98w>+Sv83zxNq1TzO`^D)G<;&**3@yq|qo*EY%XOM&X9wZuD{R49y`q~@*=r1y#?76M;g1`HI?~r163>H>(v|fDMPvV)+ zHK5^?pic<>yqE#ZI>R;Q8}GSyuRj?~zh374W$#~9bMV+e7QxNlJf5<4>SjQw5EVb@ z7tBL%Cu|E<|3dghix|EiUp|@9V~KPMxwJn%*4Y|5a8qkrpS5=v85ODfe zX@ z>W9n}2w|Au_gureoLTkt{4)s{xUIgcKBG%z#Kp8oxLA8|zp7}?%y!lDNt7>9b0<(O zr85=uJd`MN3+ili7(G(z2d;piI80PUFJ$yEDQ_Vsa9!(l8P&~cg&#q3ywxr50vbr9 z<~clmFj~7+>TiHPhNfC1%-)XlLxMf)Ieq5Jv8cDXE)mCibZRat7u!)=tEP4S*mB7v z?{=2E4RX+GgA_Y?AG#j2{~W$?UNdU!Gg&rHFS_~bI8*uG$^fmtR|0yk_nMx!gB&mg zA)Q?HqZs|cAkb5EWLT`ckCMi<&BBoED%I1H%WGz|$Hx8+`ihPdEGT*rn#e%Y$p=GP&|4 z>?0&!`(BqYyz>UR{fQoEz4K)ovoCk%y8q=*UL0CAdb49{-kD44XJ1vBl*j+ikV@US zv{4ZBxY$`>oIxGHnRZO^($iaKs#Z(0okvXYKMRzH8Qf#}*Xa9ivu~p5SRLh28e=HF z5u{IkiAf`RI+geA&g63S{bpf#8XcDc=j`#heLW22Dd^`cyvCI9 zcHA1A$HJF7Mue~OI=kRrW3<~I&Oqqc>LW^xH;-^_TA)DyijmM}rfm=NS~d5{FX>lT zG7|H-6vy7-HYg9o86$`}{zQ^#k+gx4?&bbwU#{f%^&(;my{fGy}!OP2`#9}2&hBxAW5!bwddQeK1gImX$Rbt~| z87T>D3*3H)>7us33JAXu&o;w>w5G=J&(jMzX3BRslH&)LAJkIJkUCGlDYPWo4PT@p z0ul#AEFEY}5HUBY#O~J?#9nQ@63P>tA{id0F>#2TN zLaac31A$E&(I==7lB9nhgQ*abU6*yi8FEpnP{N7ZHR?%Ok&kNsCv5uN=ZjD~g`OLL zLU~2dUTCnjjWjgE`gZAC#xGe1qz3gWr)$`F1; z@1q+uJ0t6>x_WBdIe~T8hw1Ftq{*|%R>g%xT7#FOTbgNWIpfOnK>a8}Kfa6MfKXm4 zpttYXB(Sx6H55Q>*;)LM?U%)vX3JZmYi<*ln8?6Nt3ccXec3vYd5^F@mDRnchE3B6 zcku;2oq2v=y>Ng+fw8kt@9pqV1OXKg#^LlM$C2?lS!LzURNo2yA&xEAj+duyyPF?X zb*fOlmqm8Pw=xVh#v5s($~>etQ#Vgq?{rlS6~z`fJ@0;&_X3B_Aq<4zc|T+EQ(Pqo4DFZA(G zo5$$n;G^!@@hiVP(`%RA@umOSFEHKwKswCot)C?xk(M_)i;C}vA>A>t$w-_A2M32r z4%o-Bu(UajK4JmWOofdlhZTgyhK0orF%XoIPDE7}XPOo}o(Xn~3Nr{e`%1Hr-^<~b zO=g@GkHbw(n%8cR(4+-$4-<_Fu5WV1H2hW1kuPnk;^#AzO#XE|$ul!8+?dCB4&vny zbUUcH+dV{Wbe8e|RHV-(WmDRVVLf`1*=0n>d+JvPrw#EpH)Cy)Y>)$5T0|RebYWh+ zt#!&9`&IIZah=V;av{g-+SqR#d8MhCjJ+!Bjv4s3f*g!xM()$AU5qx&u;WwrZkP;- zsGzHRc(H_lGfCUXNikl$)JUUE%C>2Loq#P7Cv?)?_XK^zLXS1kz`w0A36^Tds|mv~B>iqS;V%UxbV|HdN-CNf8b zTmAa4-vaFmJcrO>jM6hHX&AYj)f+>bO%Kz~PMfBs>0BR@RgzN>Kli@k_(!Y2yG5;$ z`}r+sC_tb0)kF3R9c8;7PP{B>Gr=8jlWOmNyXV$m>`gIy(xG}g$m}1WHer}=gj5Rm z*J1RUy`SS~G|mHw^_<8BeZrfQi^1%t*j_v|zr-o?sF*1LoO59%C;>uSv)u~J{c^3~ z0P-nGuIVY8AU+k|%Dx_~2Vv4FM_;g9Xw__p-UH(fV?+=m-5iVo1x(93uea#AcYg|Y z8ci{2oXq0HI)hct{+3dN-tMb9F;tX`D2N;oIlldgAsSV zX{GIpq3?ENAv_NiI?#uNlKVV|Ic9uf26i%=FVB;yd?odbdVY;%cARIH{7Bgw!d$at zRc+pVpAe!Z=+F1#kXr%gVW*{MuWlKK`8g`J^k*gd#|JA)a5VcJRTF2yJQBrf4RYB>kezeFSgw(5-|m;Z{o#dP=HUmJ&*1t=>)q%>jRu+*j^ zJoNLsUg_=Vh1Gc6WB;o7i1afYQ+>aW`|)z7rK%HvoFa^&Mw^$+L(Ix7+OfT&Tl-LA zZi;(Z!y=#1BarLIwL7;gf*5jWyi{004mc-}aCyx#Mm>IXzg#+6(Ea@cNr9nV*)_cD zU*Bt4JK|I2{*j`1cBSqK_=M0JjE1bUP#2B3%5I^dVLNf|lCF8tEg$GFul)0RrMlNS zFe}p^FD`Z~8mumq(H+oYeyzb+d4Bz;gD&Ie^i1;RnLKNYR_O7EWz++IYifvgHZ=y; zf_jvI(}@&nCP9}Kf?-pXl~F#!Z$xT;^#LLtsS(VHy_txcvHpQU6;X;-42T zgk%s;@XXY%>);zM*;=)j5!2-IuVve4pWy~Mn3I6qTDM|MNQP{v!}9*b`s9Ov%}^ZW zVZrTZzZ?b5x=OInjh^ij>3I%vP-=jXs%;(KTDrt(Eh6TKvm__8ldxR zr{P-`;yn2DpbC6!D8NUusl$hu@UF6^u-xRwHa@i<>!G+e#5vsvS{;IJM7j%ZK7s;PMd)!v zwC?9jj8?kNDtvp1sEZ_2nBI}z^kY?muwUXy31YJKrzg{|rZ4Wx!3=Q(EhL6w&Wj^$ zd;r6qd6rTX3Fj+%GP>f4`8ZMi^Ts)K?6sAoGmzy6Mol2&M6L5{JZ7DyrSp+WlFm2J zPEd##MajQ(DQ{-#y7?`^*;1b57Pf>V$nEnwpi$5pWV$+7zpl6Qw0x&tGe68O#eT}3 zbo|sOacjvkYR7zsG%^yZAgDxA2GoU|vmVIuBj+n`Xv;%T*SJAmbL)^he-o_??aEc5+(f|YMp3r zT=~_Y=a2>xrVmcXphD}G&EIvIf23#hRmEPFjZXPBWBpvoEFR|wpDkHWljgnwfkcux2lZ+Y^J4Z}yH)_CqJaFoX}aTpxFY`qB;7 z`X5U^SUToU)C&xt%6YP4D5KJd1#gj3pU+!u5X8j~{zG`pWS~;#agy`151wrY$pSa5 zO{}!^J73OG+KMr#HkrTAspCpW&B-3V;An7lXP2LBQx*?P*EY5Bl#sqY- z7m9-Sj$(CzODqTuI1;h-DZyOV;4uQus-uKmdx6hN&t{xbThmt!PQ#+4*SqQ;F}$M{ z19A$`9fE#d-r?~0pozh*bNuH-uZ8Y*`CmD%U?aP9?NYcz*ynpe6Bd`xPr)%1gBcO% zeMvj)wf}Wpt?0}dBbHP(EdP@fF*mk{?>=qGyQ)J3nX=hq-AP$` zo6mT3x99@&U1sY}edlI1op%E{V6{Qe&NyV35%XN!c!hLL^})}P2Tv%=4b98F6HR+Z z=%=2KsxHs4;Zua|N0eaHE86UNOkw1v_!z|Q_!_rw1ix^iwQ^{Vc;uP#RNCZ?3RTLh z$?A$10Oo*73P~Aebz%6YMG_5z!p@1hCw7z725$=yn`7IF=-zCw;n|AMlb>u^1vw=V zNhD&ndx%=D?WzvbQf55q&mE=mCMq==35>jl)4lhAu2n6WmAVWE&>W1kqwpndzG-Uu-w1tch{XZM+NZTLmM45vmCSs`XH?6;C#}V_nsxW zkn9528N744oX6h_OYx$3^;!NZn{Z!_RB57rV~Xg z*_H{)XG{qgshY8t%c_d2RfkeQ4lo&V|2hu~ixVr_NC;y)v~d}vPHG%oWK?bXLm+N# z$uNB}HBX-M+G~(g0`e;Kd6}8TI4Q>dMbGCA>p1A^2lWPcL~~OrE2ktK*T|&>`oyHL zsTDy@qNw9g=cS|t6S9d97u;#c>iPCW`1Kl#CSSM<&escXMKYYb-`4yd;re%PpXvf& zJW4G7a0HjkxIcIHBRdgwDO=92tG`puE zeG!V0&*K$4aVFho5TP`06~FiRMIOX9B!ndodYso6G3q#maj~yn$F&|SF@%fdm;HjA zz>|wLFHT*kj-piZPPc``oP@FjhuCx4QHzBa5937ffz& zw&mR=m1*hVf@20HHV56Zk%wJ*ohy(2G5%Gxh!VfRKC#MV^LF;)ld;zFZyLIj4Q0yp zpqAtXMZ^wBtVS@$MXvvmB4f?+aUJo;JU-h_=Z_Q&w~H$^v<3W}cNDBdo31&(Mg8A{m8jFU&gMb! zi54vaGYo-XB&4_yiE;X7_!(ZmKHe}lG>_qa`8zRqAubBr(0C{dU-i0~y^Zb*#w?w9!)Vh^ZH5S$w{+9=4z zn6W7?m3N6;+@2;Hj4w?)zE%lbHT!nm@7?mNmW>LLy>+LpyN#3OX_0ujmvv@sU1{fS~aE z&7r2+^`A&THr`IWtEw0`x`Hdu0f|QyNRT3GcL*Va0Ch&ppfh;#rJhv(*kH;++0Asq zah6*PiGl6~d;#Zf|BHk`z6uP^K-7E>1lAGrFx9w+Tk0~S-N_iFm>0FPm@{;J=URjE z8tc+AWj%ST{fv+j5Tl~e@!AI@*d&C7MIa{!tlorJCRl`Wgiz|C%*w#Rf`ubkizP>* zg@QH1H2akVS^4ecs{MD}V!L~pYq+9!dS86m@*RwnmAdsR#_Nyi*@K0UjBg1E1{l5; zW}N0|bpBdPCrA|;G{9W_PRZhY3ikfUdqF5sK{h%ch8ZESnQA5G<_R$e2?aGhF0FGa zk

DJTn$iNoTFXSk-1mSYenez~%}J<t5Pf|RQ>YtIJdM=I^BM>`s3JbFmx?6jT5zAo^+ z>BD7<{iXtp;Xt*8KBsFH7_W-@OwZ+?9Um+Brs+&2UY%bV)L`iS7e7Fl+4$Igyqx*p zJ_;8Hz=e9Py+aD0BVQudh}s8Q*}h7= zCdW0qG#q&{-E3IQ^2mVNAe9iu1CUb$Di`#=%qC;>MIh7p4!Lu!bk{%m4_q({IC}A7 z=)bh(A0ZKDQ#Ec9MNn`6^F|LwK9{9p5mu_b2lecNmJu%Hts z^j8W;_9YV)k+3`vv!Pzk^U&!}wT`vi#n+0^R`hV37`NU%lvVDTvOBZY* zbSA6_vu4p=!rKYVwO@`nZldQ{YA_^FM8Bw`_kositBuEGNIOm2(3(ci0rF{3_aT9x zpBN;c25PPL?t?W;#mx`NQI4HTM9fv`@zPr9_8S&*Gt15$suPfq2jUDd#0hUl%pl0c zL~c9yN@uB|c#IYnrzLc@c|!&1|wm)N(kJWFh;_G(4ex&L3>WeA-Y>R8>V(Am2f5gGP}Nvnk8$h;Ct7bPbEL| z6%aapdT9bETT}^(uhE~q?~rEO!l!PBC&W}hk?E`J9(#7Eu)Olw%=B7w7hC$kyRXu& z0F2qET}7|6dmHl|CLaxalk3mmVRxAe)hR8{-^qN~S5VYCt5kqPvs=v#p=&tR2Yh@B z5OmnTwXmP>CRAquROjhjR(IsTm^Labsw7{POMYCn)UA8_^v6$twxFpB{n=ZQ9&S*M zUku(Q1Es`$qBeXyf6l^1=B)LWhf1CKNq(-;bj!vNdyxPa7;!2~A!dUpy`x#CS$$L2 zE{>Osb({<;beAf+(kQmW!=y>?u@QBtk_?DDCFpaiF_HXJeYvPWA0C7wQn*eJGTI9xj21Q5vGLp zea(E%Cy~^;XAaF>I#vueqN{0AODp>;5pE*fTVPiJ27CqQPrv5AeF_) zD=S0<*Y5?c%EFVAj#4B<9eadoh3A#wctF5K96=u`3z+?g%Qm`G2px$I;r9HJ#5m>e z%gX9wxbaU)ue)8k^#>b*2a<{q3Phub?;#lDHrQueDpiwr;v!Muryu0Pvsxr3=gfB$ z>Jv2rnor~7K7dT&S^BU2EC>6*vDSkVT`Z{jqT*!QBcYF_{@!jK9Fg~Z;1n4u7~6`<6|U!-gRzVAvh zVP>MDw5qLarI`DPe$jtXE-Y2fKP){;%*%9x8lfygQ3VRs(a!HX=)gd(mzAr{t9jb_ zt5F)~{uyQyaz0P}&{}_+ZN$uYVo)ZW@gfk1K_U&UjmIJ3g3OuF(Er|F>n(G-Tw_68 zD_gPX^G!LL=W7>t)y2QHWIohRry>NtG4vs9LLeqwN>W8uAuTCutmEn`r>+=%PW-j- zg8SaBS=!W%63xX`_XL2Lioj-#{#e6@koM)aem{pAGl5is50p=25z5;zmzk`BvGZiLgnWDb^)0n7k(5=^a9=l>X#PCxd*;zQ40oXg zQIh^`5!=D#8d=>tql8^^RNBXI#jM4$Ry4?zNSBFJFdU!THh*ydber;inj5XVzZ_2O zytJ;#V4U_dr-%NR({0g+)3|58iL4Zjn=-tv_55{i7Z;X2F+hi|qr`rml&jrQI-QLl4~ z;|3Fh^?aha$@t%YBt^3q>RqWw;9Eog7&sHU=qX>G;R=-gdin#BC2zbj0H=N zMF&D@ln*Fwpr9qXXgeE^=f008odXeVys}tR|C0x8R(rEGf* zo6Xe^gNw9cV?z{aN>lIdwcq?lsNKetuw%26+wOO6{$Sa&-9?qp#PR-V;$1VKe?9S_ zV5uNr@v*0>5ee4|jUaoWeWbddT0vd1WypWhdO}Q%@g@RcO?jT*(8fR={)U z(^%<`NploF@x1!9|ASjMb8_Iz=vLa(S8V>+v4zgg*NljJ2*^Su5Okg#l;~v?V&3j0 z(IXkL_*WKvx9CH5tU%AIX3hBluAlk}epnVLqA`2yQ~g|z5z zwTMqjIuG*7H>`$0Km=H;5XX2821X+I-__HQV-7cpO;z%yknqHD(nI)h&M>J%)aoNshtuOcaoT!p)`CB7ToSbhhsj;lhH+?6UNnB9e zA24)vsQC|3q$}Mf5g!`u-x2Vi`{HV7-ft6cc6n^Pk)7-gMXz`SkhY|&}0a&la>`Kxr zfs`HkiR{vH$)L&SN1tDs74>c34ZfC9cx&QXAi;OIQV0lYqDR;Br@^oOg(8T>u z<>ijml@mv`-N%(IzI&zdE&;O}@MoZ}&@xgP04AX4>%$gr@i1)t(!4k%WHzfZ)zJrxs1 za(7K&7m>sH>V1*4nyu`qvP)u5g_Bw;t=i=q2-@bw+MM*Mm~P7Tfjt$3={4x*Rkxu( z1K43|$IrEQ)~HFMPoFZ@x$1EFWiEqq@JG8S?` zaEPyAy;d+&72Q^0ZaGV**%)?5495Xj095Fk-lOputj}FDh{K%TZQd*H9fy6$&Geo~ zJ|$VML7GMBlo=sTA@KJ0$rOh+Ix#FHVfPu9m`5j1&+r$;Un%Yqzq374q(Hv%@Pv{>UKK^zAmrRc z>DQ~y94L_u-EXSKt%gl6rH(M(;aI&lWEbTlv35&DE2v|_=|1l>Foi(Sk92C}7gM6! z{|Q;Jh}|d%vGK6*0`Rd|_fu_H9xz`7evV+_;ZdM$1DducJ9PGBVd%s1Yo7S&4s$Ov z7hk!$J_`R~D>Tj=!nk3oeemIr=if=esnXbl8l#7+=Lep2UZjG zg$T_;p)c7lKxgNu@{&7;61;|Jy5|w!RdV@67p? z`LBp}nRYp`YXraadX7QueI}YGg{8PIDqe1GgvSn+u8s5V}dv9}{i7XPei#`*40>li+8hgWeG@hxI?- z?-DpQhvvZ2VI~XGh3el;Nz4Xlg5m#69-__-lKMo`bLQBRG2dtKlAYJ`5;O$955 zvJfQI_4bg&-BhAR$qqM-fN(KO*H$8m- z>0bMvIEV$k|NpV$xobYt*fa@!T}wmU%<*wuE_3g)BU8&MJ=DM+PaAU-1m|t4!Y1jr(zEK$YL7Sz?JvyPShe5 z1>16Rg=KrpTAxC{%nx{9?X0=h2s;kdg@{)k<3o<#@q=@M?DOHN`HyRwOOpD&fp*Ez z{8+!*g(ZTx)4Oz<8IQNjO^+5mJ=wXHez5W}JXLi+FO~diCF~y;h*_ZE%Qw#EVK+Ii z+zTS&JlS?wxgwwd^mVIo!>k-9v1Rf@Dp7)(#%Vdhb$?6B#Vd|$ID(y3gvN2>vO7cj z*Ax&w+I4y1_rG1!|6}>+WI6i82%J{#KlQ=zN-002kYjvVAZ~4G+h6FODZUB z%q-sSI-c7d`{j4BWAQ?vXX0aF-SUt;LBoZL@0fM#9U-WGdkzywO9cy@+hf?`V zbAqnKv+EMMpZ+{y1hoVu70Bq2(KK>&`{4h$qj;$GqgIV(8OfXE=D|+&IX^9Td*gQ~N3}xryi>n?Q^1CC|W;i~pWg zly)2d(39632}^C(uRpQ&T;W<4#4GVmGEMEg=-XbPXRetDgUX1`LPHpO?dwQm9w03{ ztBe0)e*8RJuJp+-PDal+Vz%2RG57Xg4(;&xP1SGWaMFQ>7J277$Uks{R%HI4y5;c1 zut%<6xO z$93**J+2xiO3+uzo|@37?s{?kd1u;eC>T`m5fMI`B&4Pj*00!AKbJyrViNyS{tM|k zGjqAN`rQgGx@$kW?6_aPEr-A@&;cFHX`dJ;`@d;*)Egk9P?3!{=O2DMJa1;MBY>-_ zBe8N-i>9aQV(dswZMaF!loKW+$h!R~z1Dp^euNqf-XX z2ZWoZv6u`^K#1P?|5Lf3){ox!B=os?&R4bysQgNDAr^`yk)aB%SD_ScC9 zEH6;C(D{_#qWoMgvS~KyE)S94ZuBy275~~T>QBXJH+-;6Df2HoEa7Y&G-sA& zr^?%n>&{?(Kj%o07HN7pp_YaAE-VwcVi4|vwh{C$!=2_0$as97MMayCIw0?~V#AG~ z&ErQi3s>E8zon-&eG9DIe?6e#Ob9Llvzo}L9f-r|ai;u{(m`SMGLm~Ez zl}u0P-x@C`q*Wl_Aqe!4Xt|9LjC;IH@JaShQ8&kP+KmS6IxOqplAmqzZ~;=*&4d< zGY6O|K9r@hwbyj2mj0w6zrU&3d3NM+^opb?1X5w*EO>&b$N52g9&tcsLr;0uOKs>` zHOyTPRP1v#F=(Q{q!L41=vEPWMlJL_YQW3CZA@VF&f7)XFK*A#?#QRI&6rhsIK3GCMr!NBY99og*VpxKv8O7Fg{l;glBbTknG~(C#aVvh2 zm<}6V)dCtsF?z3I%yVj}HNW-Hay|NEFr;5FMLqG4SgUK3^n2_Z6Q$2?jJc2(fqVn( z1nN0&S}_2D;HTIX@;D|=kF*9QH48EWOV4O4KkF~?aSO>dU3p=IAP3$)5(C_8M9abF zI>9i>S*QF4KbDOg#*TigjdT0*aI3#EXJ_H`mME4t7<8!VfeFE==M}7BltsgnOT{*q zkJl5iTxfb_X{-5U@%7(R)BGJL&ev$DYF)twITcYsq%SQFDWZg9{E_bH22B>xcv)Vc z1cS@*Th?5%XG=7Em=}+<6f`e|LRHrOTwx@Znzl-M@V)L0$Z!`8v1j?#+^*}rcaw3v ztfM--(l_yxkC!~#O>I(`;wno2;U$JDsqFK{@jKG_p}Q>9wKd0kYKzKaH?2IPHf})G zSs?>X3ji%BB}U={ZGITjdCYN?-EMRDe5b}s5$&2+>0yawovl4gZdXT4v4wP&AqoYw zgkng#bq02A&s!ld?FfVm>#>G<2f6+gAANIRx*s@XA+Hb^F_d3Ks_KVxl=I&Px zW*_;rlzg)byHoKvWU6YSD@GDsY8Kj~JW4fci%nw~s}eyDildP4=8sGlhVN$4A6ii# zg54n^8aba~KkcdBV2bxWi*f@VS>LPUMH+Ct3p7@~OkqqZ&jx8rt$ zPX4nMiSB&WPThu+Sk}Jcz9aSr@`I8JP=|nCXFOz~k-$Q;X{B0sVO0f>p~{Wi+Ea5} zeA2Owe>2MZWv$zk#vCBZCJ*yjkVMRC8s=OkoakN^8LLj7{h6(LDO-$OxjIKrm|7{c zl4W{ve`o$jS9qdrF+NUbV##Cb*cR0v1u zRVFGN1#$WXPfUNG7G*U3jp|cIXFDw_hZu};?PZ*=yeMv-xRNk`p0q`s4a_bibrBlY zo&d~#9KT~+-<^s>Bl(W&?o}n8r-?HgRX*-HXWIs|aLti(sAuik#1yFJ}*W%)M*K1AtjYA~%-DX(5WVHS(iG5hjNC7v}_ z?vwY!`lKT)4M(0`x^(|F46K5(7)V#6pR-bo@rzfM6^y+(Vx8U!y#2I_Yne>>(lSop z$o|Y-Y`VGmn|j?Kx8Hh!J|CV)aWtH(-@lev6bPEvW^`Td`cP08`^*c`-FdXsqPZ1w zoVDvS0A6KagGPD`wjt1hod0@%T|8^;ipAxx=^pM&T_hIErk6i3hdOG88$CI5ykj3c z08b;57#u+QRACRmFaqS~>DbY(qfqL!2w?@v}`n{bW<;2w0cAbqi& z0T{g%@U%1I&8GTur?+&gI;wkCdV41-aIdCoYbS~EVlBbYI|#hMcSGyrpWX+77ea0< z!rO9g5N#nO)W%Z4;&xX8`!5H<7#c!KEc*X|x%md-LFUzuK4L{Vtv{YFdA7l1%0FUv z^$F+9OQDGci=u;zAym6EgvaNO{UY1>EzeVD$F6v8h3sr>F=dCFYMN6Ebo&=-9|)i> zV&fp@LRDKT&RP41gorH?&nT%UD31JtRm7s1R!!1ut+0~t4>4?3{K_?_=x zu88=3T;`f;#}&T9r*~x@Wag~h!OM-F?gN+(WnKqp>qh}XHS)hL8eI?lpG%j?8po+6 zW6WeJi1BE*Zt?hb`hge!5!F_^RbILC(AS?y2eJ1FDN3B=s^pAFIT8MdllHe}aHRWHSC|2kW0o-g#SuO@Nn4UYAK zDclUOTZk+8#h;9r18^ea|J}hrPoP0N7X=rzNRPbNm6e~_(@r>(qyJ<)MU2-~;K=f+ zAC>xsR(=P&SKjFSMsecwS=Tf1F9Ux+^`{uo35u{WJJsd5{&*#T0E$o`ObZ|vb!g)M zV%$-z1me=*-+`?1l6aPBVc0h_m!17;z1*sAsWd!t-n|5FERb`EBU&!L9SLAi{?{S- zk6%!m-h=AXFR=f|t3^U`oMdl}!)fb9r`-GQOKs!y|11RzS&JBiFmbxUkhHpArtg88 z{~uxB9gp?f{%w@xpYP#BGW1-vy(az$E39gAYc_u?=@oLHb=&3R z7YU5)%b0dAmPN7OGsIU#kgk8FHG$If}gX7}6;M z2M|9f4n)5GTfszuWSu%bi^Y~MT9)tL;>9U$HGX~VOaMj1Zr=kWGI{+TT7)r!V zyN5yX_zd)1)gJZchQ}`PYP-oSHc?2>jg2Li2>4u7$w<+8i1K@gA4Dw2q3bvDSs%Ob zi32a-b|jgbeJ=av7;@97$k=OK`reay{@RLr+IL~*i4y%tAUdA}#JD0ew?%aEoML43 zsbh?<-B;8rD$TV!)N`)&z2mMf?LqlKAz2%VA9NqK?|EvT#uXRB&U{rULd#|nm+>Ed zpPc#Guhg0wBF_VqK7rd>5VE5V!Z^rSYFMv!?9;1u|G~a)rGejx^|*dsf7x7)59s-w zJZ<#L=Q+_Gpo7>tvR;!DMr|CGe)=?%>}V~vxJO3s%=PVbgN`nv(IQgCIoeK&-`tB3 zEQDUdh&mmHHUNmY8#G9r?lv2uchX!b7p_|1?v7)bVN^BP_{U787W*Y!8x<^s_7rGo zUHk_VS807@Si-X;>-aMF$*Jq#E1gGH9*j4f(2W(5*{+J|`%4LQN{~~I)((@0UIh11 zA?qndoNZjjz>N)h->)welGm)x$OwZn(J<|OJ4WrFq=x2UD@d*<(DRWMedbOGT`mnqEm`MA&vjNHQC zO3i0@_}A4kch7dSGSd1hmF$b{R};%;tN{~^3BS-F$;lo=Qd)^V8Z~%S6}Z`yE%2u z6NUM7=1r#XYgYiBGB};k+>(8mJIyRI;HTAXop$xKoR@TAw&2EZ18JVKjV+RF4m$;0 zK~(_G0qY?kD!%~peXXQNesO&Y?r2j^O(PlRiX?taQ6ta%C7-RwC&c&bLoc9Hf>IZ> zH+3i#^L<&B7B^XoORrp_B8u5Se)%mGnD0s4GbO!ipVjcn~HttgsWJ!4_x_3Ruu?MK5p zPhYH;M`uT+un5otmV=-x5;XUz#0d2eOJfge+4fT%=@PDYx_C_lG7KZX>iFlA3l%Mh z6HQ}7{{hGXLqCIcCo(hyq&SV|h~+5Dj0FXISXj(hXSKdU08y4w5r>7;6>ndqm+m{< za;-F~3|xlg&eY_Mi=FMUSgKg(YwGt2FW)KnO_K22@PO+col42qd8Ee~p+zcS-{WR>-AC&rM z9Hz&&IqRyB`E&Qo={??z8;9=H3Vj1zV}nmNHtaGF$tQY-k*O`ipa4slv-YU z7WG;17thE?Tu+V%GxxSsdk9Dd_Z8ehYt)EvjGNHrnkZ|Dxm-DY=4b9OvaOnwXbt|e zc&P*{zYGktYd5Zef&;GrlFjZ0I0m^)`%5^<7RUc|e-Si&)okMRd9s}WpVY;$99Ppp zel2nwifM)9_zwa!AKWntwQ$E@ZGjeAxA-0=APsSKWVmCjELJk@D z$f3Su|7li1pCKd@Pm1i(F;R(#cw<&6*RNTg-r;mt2Ze|OBZ}8#6xma=H>il<6wxTn z`>+^^-TA7j(fVb&k0jSFil%)yu63lg!fCpbclpyy$DHsy2TE~3yD{{O@i-J9&*~^1 z-t>F--D1kA%7W*ic0F^!jb0)9yZ8aol-&hg-~@%7VF9G^Nq8tm(D`kNt?TrBC>~qU z`&%CSU9nJ?I`JrX(lOQbUy<*Wjw}G3IL!G)@6-PGnPd#B&}cVu?3am+l~h7Y}&qVnYwt9 zSYwJ!@ajNE0Z_#Ir`ec}5v*E&)ZAaj++H(ZlDUB`Kk&wh({IdUyqeTLr4&0y zgL<`RiB^xf)V8! z&ZDZ^$wcQKl0LRmAw=~V5<@}=-B}oUOu)#;5z%`mg(Gdg3TOA(uTjq>b60n-wA`0Y z-DGR>P$DM>XcT?=3rOi1h$r2;7#e3hFs}z$8v2hswD;tT(H1ze9$%2rN zJfFBA;=@aY9)C!RRsd7Go0g<{wivVJ`Q9{M86hXz9rB_GuY}{DPSS86`Go5735~t? zFS`wK;em^W=;HR5)pN_0Yx)Hh+gYnlT4bjK$&V<=_0w8QTibj-1IvMf5^3?b(1~GY z*<(ViI(oPlIq%%m=jTuxxm_cgs5m)c;y|SOn#ei=3+TXdLsBJvuVI+$sPmQlA;mD7 z)vJZ+&QkL9fu3r&m9HhXyXw!IN$i!Gf!0QfQ_c3T+LCE?>AE#FbhK}TC7p>6dj#f%V>|)Y~;f07L^W)yt z#g0bpjiDvdvTC4LOhhfw^07DXj*F(PxAp!3I=Fb!Rs5Rqv{$NTabrQOf+o(tiZJjfxm#YJzq71ebQaGM) zmg?2!zhQ-+8I`relVNzpk&u9V9Z{DK4_srQ7}OX z9U3Y*9Ls=n!kuRK`_2havUB?=NZK;^+~4K!eiYv zEI-Lwgm0ZAUSYSI^tk`+reB1c5a?=t&=+XBX7EWO(j$wzZO2$Fvzh$Mde^KbTjVn- zqD+HPHq$o^UX0KBvn5fs_QCt=SilrIH@gsxQogA!6JM?Dt^P4eZs5smEulI)aHnX4 zX_IK65*7IZk1LWDbLh(4er(rf^yk%AjwBhX+)4Qryobk!7OU&NBQ0m zw;?#yK6|y;qz<<<{42Nnn)4ve*N7PHX?#?&kP=8a^m9fPP9e|amtdyy^J*H^J#T%& z56_}lUXFYljZrMU&atWc_9%lQR6s#?6ihbV-{+JE#%RkSo&9r)E%;d!N8e}m{WR2%wf9wJ0?0Lze!#e*&MgF9aODU1>&TQ8;Ccd>9y(}np3_MdX z7YZh*?yr-4n5EBAF71?GmG2}ScHZ&|i)pjMim+V?apGfRZI)hzKck{BuuOzLs|-{B z_x-uw+`C(n*Djn%S^7wp+nlE#y7HFOd^58A;q^BgEM$O`6ac59&%p&Lkb`rl(r4Z( zeBgd<@D8m!@ouz>7W*jSP-wB#<3WXI?7~>rQLX^Ui$?FSbqRCsI7hC>WHyt&W3W~z z8+6j0QmLw^?4uDjtGi?Q@(sRX0Sfa7z@Y2>@2VL@i&4;KVNWLAX~X4Zd_{{%?X50l zl3nn|eVXqwwOtz2;PU)07)>A(1QFLt`C;?Bi$Z}f8QSwG9;&MT(Nh>Pn`mx(y+N&P zsrqFj`nl5#9?DpT0aWOHqMEQFuiL-fpo*nkle2$i;+*i)*s^{G@lr*N^S|sCJmr1G zqfY~!GUQ93&m|5zBO}_=|9z|OfZ*wo#;n?urX|0ZWm1>jwrtu7?=JlFEWsY!1RW1^ zf6!2H_9OaO;5hAgG8O&RUVTqin9i(u#HY0>6#Tum@xohjnI^)&9&74gD?{2HQb4xh zhB?lNIX4DtH`)46D&C5%Pt|BS&)7}+WS@WkPY-K}tKs?x1i+LaK^?6n<`176yCVsU z{j8G6(b);ZIlW$!iIR}w?`qpOn8rmmg6PNIfYucPM-Eymy-UJ8(^a$6H1bMVL_sDJ z2E#vaI7I^dT$P+@w#pp$%1%Dp`Gay11Jp$e*_vq#WWrfICz1H)1dBmjqZYXAjOvW3 z!|+#>y%p7s9xJz%gA`IgAv*MNmcPfGi<6R1)OTEA*Et>j&Q}uj4Ue7JBC2=#uHikc zTlgz*7T84r@<0*kRqKQ~m%qoJ7L8wXfAyNe&vi)2;4%5hySta~kE@Bw?Co85H-SKa zB0N*X;PCUu?9)2(V}!blBqc$p@OqZJ@p4GtO@A$R6+F*~J{zKw2FDKzH#nWvU*(<$d*BQvl5Omi{8wA^2k-j(|Gj&(C;gaZk z-+OgkZqBw+c%&1xzZOm>nN`tj7g9c4T;~9#qYTY=5Z}RA!%=iT5vu7)(l3b4)!19SF{(H$b9tshbw_% z!Q0q$8w8IQ#5JTETl>k+`zu}qEd>ML5b?D(gyD~`R@}x0a+e9}gUxBzj$NYU+s2Q7 zx%r2ngEKPcowp_MzmPH{+@rs{(vh5)8p18aj<8d7PSL(g03BV)AB^|ky-=~EVYTOj z{}gwyhfkrEs`&v+?ir7UN4%_<5ujP&9gj9LuG36j#qXJ^ym?>wm&}q8Yqcp^UVy>F z{L|)OH9!|-q!f9$3u6uG)<1GhtURS`uu<1E#;{zOPFeBqyh$mM`km3hqUmek1XTc+ zGUCRm`+y|mBB@WZ2WN}Gka^&%stfg>g%!a^a( z{U6%xvcJ=U-wqWr=QkpUqIu8j6>$zbHux@fuof_1y>!9)=ugcj2RpS6PbhBlm#~nk z8m=UgxThK~tecWE$nZg?TEZ~RR_iQiC8!-kK(kX0=GmKh2Cptl?B0Il74{%g`OjSo zTKWia5gD6Lk39-^*kZoJ8N-MtWUtLWlm{a_4z{}g?|+05_qUF&{wmlW{gtb4`}5Du z3Fq1$e+Qy7>fD>07jFJz&A-Ku&7*Lz^*0)+_wM!!zFlRAI!)N36S8}uj@FD;{YrvY zJN9w=AXyZUf!-u&$rCY;QB-uBSO)j!@|(;*zyFF?WJ4bvOZC}WXhjEaV9P)tv@iiQ z02GNLxuB^5l<4ZO|IP)KMZRNy+kUhtM^^!R2yeZ6`>%waO9GDBBvW#?#9SCM|GvKX z%Dd8cl=|Mm0~Cp$jQ@IX&9sg~i0`e$Y6QO?i>1H{16FQy9NvwJ2LmXy4!y3?`rNMr zW8T~dxDstRQM2WJ36D1>&N~1);Me=-xy=~Wa9%R z4~sPW%ax>QmI4Lylwr)}_H7?oPnjAwl-um(p{l?55f@DXl8^=Z_41y^o1<=GFLyhy zvDDQ6>*Xir`k85cmfxqZE6Pj90U}Nils)L#>2{b2Xp#2Be4ym?;bKLaAX#Xn{-8q{NWZ*bTRYjo-98{bD?&()n@JE^^-sc zot6)ruZLE&fEGia7Z&3dzOruCFhh0RbEoXv#=WlUWsO(Ag_?J@03E6U2>P+jAdUH9 zp9{3vi-u_>tFN9fda!#W%b(XAgGz;rn*Ph5b4+!KA<;xo4*FxG_vv#On5;M%BqjeQ z((K(yx|@ALukfTwN_$9TBw5G)B;!&3Jll?f!Q$Y&+JD@OL+FPFY_(>d=!xg(O&j^W zEFkMg#*ur=wNWbr?`O3u2Ll?e{LV$eS~wQ;dUc0zEW+biexq}{%JNC#^W8 zPi&6H|M2(Jm{Rv1asxUji$kpapDUR2eA=e#6!=ezA>ZJ(kCT{KLqVr-{|n_nm5tbo zx)XGQ6F{c~`3&fDnM3Be!nwE~``4Mix7K%TE;4^C(PyEQ%HawL*~v>R8|7r8^JRbo zKtBi~g=16M7`eqYFDy++Uuw>bN{P<2J~6|6dzG&xEkofh2p~uoL?WW! zT+y!>&c$CN{Q7$N&nH#x`Z7@_N0gKB9&fIae>N^LD(huQa+d)*apB7r$0BuZe796dme(tHkvwD zeO0BYs_U*R(1CzO_$&?vWgsv-q-Eu1DeW1{R*jbm=U7un<;}(v6AIZKuv9ZYlhXc% z`x8+X7e;X0_+c#QL;7IDvqal_jwfuTHpa2pYFWEW?x=|-M)rOU7Te|nJ_A{L;6161 z!|@PQH;gzhi>qI3e3zK5?(eRNo5 z#r31IcAPnS9_MzhL`YoxA^CLZYJatZ^UPoHe!)P71HMiK*CJwu;+#;6_5PG6VUnZ9 zasTYIxp&eu53`ijt!hk*LuwvlL)r&)PZC5r5O_ex1cdHgMdy)3F0Nvuuj+ZP-#?yx zHZ~`fmvih%-`7X6qu5pBKqn7%jp+Lugzl6GPW}JlLL4y#daoQz5qHTO!swN_V?|l# zNz3kq45a6>V&ySK%Y8XQ%_MF_@^S;#fyqjUBRwM#a~_LN)r?JY2z_Xs2sfC6#*Ype zr0+(_o=@IV&%-alts2InK0*!YNUWGIL|e=24DKvt z>%61aQG;yc!2^%brG;bO`E`Bfe0U!_=dC&DB9Sp;Z3uLb zXop07GQMNf5X%EE^67!M1^U)Olewn{mxg{*8YrpcuF3TYs+X)6hX5U_9~fE<0 za{d;iDjzhlX!)1@4}EVSS57jk z1cepnS{FS~RT(uKI73A;Y-8BAp{d9seCme3BzO@~_7mbI%{bHx6K_sa)^-d{M0vlk z8nRssh@wdTm*qY@+I#mxjNP&aByuXi90TOt?I3AIuwD>tXwK5N{K>>m<{b|o^Sa#@ zyz+$?yXBJfD<}r6N(X*cfJg!I?m8wh?{%_6Dudwc`s}r3^0;F(o+F;ZbB)Tm^`V=e zWpr+s;zM&@1qD%vZtlzX$u0D`zR9)n*j}`Y0to!uM zqaQL76#2leM0=Zl9QLZVk^Gx$U}iNGFGl(@65nWa*=(k&Vjyv*kv*?Bp~$@&=wN~h zvfi)5O3!a~OdMwK2ZD#|f-NeZir)$iw@77A&8;p-X22fmIEjjJ!uSM4PR}Ck6k(s^ ze+h-Y)wytFTq9q9u&yZ*Vc;G{b}e#7vm8#n*Xx$BEs73PBzpO`;{ zz0!*)d6ugXu=rQ&O74mwya#1)ULfwR<|xcP7+hF)|?(4 z18qPj2g{-F!6^{4-p3ch5l_eFdIZG$39Qa8RfRWE5K&8;UI<92HNA2BE!aTHsAkUS zcUz6D2YM)F`_o4&(V-W$P9=54%^Rjo;*r9BhA;o;%0Oiyu13#!t=$5^gp=} zFs%8YeFRcG*fURd;9WJ=2yHSE^6;3bTjKFN({dzLj>MAGE2NMpnpZ7W=3*QKy$krQ)(vBKnt;O773A4hbN$sZ~dm@a&(kfx#`bj;^`{O)nDa{ah7DMk-h%3iUm zn!WQeWyeU{bvqfahEdmG*;J{`XF)f5D7kCebtq`6j+El<<()gN0-J|uCt~WA9j4hg zdEA)rsr%PV=>DP9o~?^T&70R1)}mcU*4deL z>j2@~u`$orG%l^4m1ooYCV5UhsY(bkUihH=3^9A+>oL;rldlWgK<;vfLH8)FMXX%U zDy755!)1-OHnWZz*4AZbpi>eNM*?6OA26XM<WYu# z&s99&KJzO(t4f=ptiO;q9IAE*Rq6Mm2!mGc903AOfA_0gM>Q7TSi7gYRe z2>e^@tGQz(vq>n(S8}aq9|0Z2auKK*=!=0=_ZcrlUzyKXx5{KqPG?&`-IAw}aKGjH zgM`yzr#1Nb#5_lRD5z9*c+ zbLw5c{-h1cQh<^qGol+9eqNu5tRI;xH zI>?Aa8XbQ{G%U!V_AJJQJ%N$8{>B%@8?C6=S5C{f5N6AiZsqw!h%Ua)2RhIQ$eW$+ z#W>y@>$e3L(kfVgDg8X{G~a*LFm;#2>e-#8Bn`6jS`55PK&K>la4hS?nCpvsvi%zC zi&#`MSB{oq(Kq=b$M|#HRlk2#U%-*V@x>_v$TNzW#~{@I?}$?z5k>luWK0i+ z!q7zjlQT`*BhJOnzbx%5D!V`J3TwYM9n@Ct%{w#7k8r4Y-2ZH=s$J=Jp3@?4|#U;kr=jYsAEazsO&pH(rBTXci8xuBxWr11$EX8RXHP907I|tn25X1Li(kr>v@h$l{A9z4EDS0 zpy{#@1PA-XiTLyiC(4~A!0Ukwxf{(!vPxco2fJ+>KjZXoqWU(_335WvI}D8+(kC!{ zqGXnOzB^ju<~1iRT#kT?f`d4hc(3e_Mn#MCslchRmq4o)-%*Z`dmSgCQk{;e%z7a4PMSDrPNM|3VGg5w7K&L3gkBFlZa6BQF=uOfyf_4qUZ|p9~TEx#c-|AuA`+|GYTs0e4P=4xE z*&fiLrU#+5P-G5#g=+G(7ufb$_kMQfnd5!IXPMypL95#PkCO zpG8(&uA4Gkv>j$;E!g6j;$;}JaBvyQS} z`+iFVC%Ve@Vwsz~O_a^a_ITm`12^W%dBtr5ubY_gSyS8#(o!!R4Q{TsK zr`k}iU&zbZOyImk{_46+5hu}0NH2u=-oa?Xz#5E!Gdz0vlDKFiUVTEAgk6XNf$^ia z7GaOv#-c@)Vr^~i`or-;s~#jkw6%>Cv15GNfE52HXx!g?_P(3@3t8x>*WGa0MpQB1~jO+hiFGEZF^l@y8IsfV2%j7)I6Big{s?R9uKa z*_`He%Ie5>UiTeF^QX>D#ni*cG7onDopguo2G&U@eLw6cf8~7q#Rb~go6b6p)cTHG zXtTW!pn(r&<{)9>FNe7*L?h-60r7T{uh;^D707>-DpF=XAvNh#y1GS^ylr2R1`GpP zNQiQss7Dy)KlX~=HM$rn2hHP=@it0v12IHSGHtXJIVaUFSw*LgRmobiOII2>7tbC% z&^=t7zsf_2>8;W^1-aZ7bc)=CvVwI=5xXdO=^p&?F>5BPE)Wm=SoK`oB1ad4JdY@3IiR z=enddPMPDpPTLKRqyK14y0K1%69#*k(7RrXE>4+43paR|ql9}L7iNpQNbX7tjQl-L zc;Ec5%(WAYp|>yKO>s%|OrxN#Fto+q=hiqsjLar7PUCYk6fc}7;onvfDL+F`p7&)~ zFT}_l|CLhZomoh*loy9tU1%;@izg>$fj!gz*Pc-ZH1gZuI6914)b?$reY!h?QP*V*&s)iti2LJS9Po$Eo!pjf16Pec8tdD{_C8(u_sIm4@5cWnvAjd} zyAY~@ z30j(Wx>KOTsQc`_|3CX%MGKN5fz&mfDhK0>Bicn}#0oD~@0Fao*pv3^Y$+>Nm4FOOiJlaY4QtmaR?`*57@hlv<-!{r1Fptj=+*~Fa-$lzs- zD-v@m%xhKj;DZhY>bJBW#ATARCfG|7ow+%kVxD&1>|p=58Xc2Zf*T(^#`(Zdw6P~9 z^@cL|Y1p{BQWWZmet!oabg23p8IReP@E6m5h zj}amZz3`Dc;%^Us&^`SMpJVhbgr{YZ?32Wz{H-Y6u4o;;U{Gy0IoBgb1C@IgW z33AwJ4 zPk6>-^D;BFK6KG$$oT?sGJbFmAx7ThA^O9`(G~k5{XJ`)a%w&1R;jDSdQb{il9$~p zf=h9qZ=8n2cc|avLpspT7h%xfQKyzKe{$bnuPFS`;bYz6M(mPWN<94g)O%{`x@Y=- z--59X1B8+2YVVyVkj-Cat6}l)0vBXfMc=RgEb_k?9Q=`u{4dbSLu3bi z{Qu%H`tnjpzRab{e-;5scr!*=<1C>Swl{{CFa9y6w!ihBgA0sUXzVS3_@)0G`u!GX zC#G~Zw2sAo<{Q7=^DsuiLH#oeaXW=FLEx!UtM?^9rv&b7G*@DH3Vy3f9m zUXp6+_&Y)H_Wa|$R|2N`KGD$}%A3_vAOIkWi=fS|S&Z`{TWIZqh_ZDGo^Rx;P=S+9 z3iBnI^pqakJv+tbCrw8o9t8dAz#Q6VFE>97H!rf%lL*SO?6x(hpK&mkVbQqGGFh)? zW?;PD{6bFIUC9t~gn7gzc| z1(Sc<>;`k(26(>L)m#$#r8(0{<8J@GCkm>8`Qit16dD(-^h&PF^Ib%j(tC zcbN$e;`r_&kXi}}@N(eDL!V0D7-qRf9t#5pixzLWpGNPOGM@;w+1IV}2o*f4j_1{P zJTc1)>QM+LoS{!;6&Y#*mtMf|qPOeyl^(5-<{S0ucLRKTO69Pqx*hhMZh2mt2oM80 zNE$?(*_lW)9JqyhfdW@6#I=LWNQAb1s3NY&r^ZS2+biAheT&QH%Cz?lOg$KGfuNq@ z4vZ&=T=2u0)2T3TgY0+Xf%iSw4q;w`I;Yh z`{$jb5iE<_lf0QCNZKsSd9l%iD?=V->4}RVXd|x}!z_1+kDPQcFJb)r!`IR~J=iPi zjq4}JN`jeVNg?%fv7hiDW&(~GT>I(sjggbiIqky{|yg zi84i(rpyvp)3g?n3n%`u{+j*b@{IHuZn^cq%(TNh9G;Q`V0c_R@!qrS^8EXqR8c$* zqVD8vmE>J#*mC+E-j(5h763;UAHNthh~5_+Db*M*if}62Ad;9mo-`s!E_*TV@?B#6 zfw;^|{1n3uMY1B5kg+NU#TQ5lV)NwxqfPQY9{5i@TV(7{bhPr@g5QLr-0t(-_4P=j ztYx|Wc8$$uP6A(N;)87ueE(&6Bev_7yg2t|8i`{MH3dyvlJ4G>wLGsf-aJ1A?o3Dw z6+ntjh7adYF0XlBPRS+bT~IFD)Fgbm;{G#WD_d~>$x(g&FvionfDKWNSPVW-jQbkd&bb?i5O9Jwi7dECGY3PQ^pUsp7ZS1J!A6ZyFnQ)+8#caO# z^t~^_slALZ>+B+umQP)3qgY++CdNToN5}MS3d-E&=#%rA_Y=N=Ltczycf3^lgmt-? zK;i}11%y`& zZW)wxPV&AEjMsS8q(=xkSq$bsqs2nVVGPg3)9c0Yy9=g`ByX$>X_-P6h=z__x*{ql z$y7ZW#3Bp)$gd0-1re4=PANR^;~9o}w`>*6KX*rYKc7m{pLrK;p-6Jc?(9`{i<+Jd z9?<2G(u3r#_;g`1>8qxXhZ52M;Jn&r&V0K(pf<|a&EuD(?|kz$`E8mf1mGRMFx{u zlVtf>Bf8XgseUHH?#|aP2E1qo$z*}w+PM0Ll`^eWo!W%@ zwe`nr>2<*Y4yie4-BaR%5kpL8Jp?;$E(_8vy8r(6y@3C5c8Q1Qn{TPi#Lwjib8)~C z2eT+(`ojJ@_CHJsjx{)P*7I?1`j_v_55jA|w&8s{W_Qo$k*UDw`aC`J1wfckGtG}c zsyIY^!L^^d_rsTDO$krPV|(%V>pX6ulU%$3ShNr21n$;!&_qJYk{Bx5g+9*0ag5vu z`I`6h;$)Cc)uk@6N9}LIDO-P(|6HQ`=B%4$QBz$6>wz+W*@FA~Tq(rRWfnCnc;5c; zN87H<8~;Klbs&i$*3BH=E9L(j&I?>h0QQ7bl7mrP-I*Bdpw{v=m*eQykoz0I*R~wB zVsbVA5@z!jvI>^s4^5vn2n0H1m>-H3vtfG}XmlrN%AK#=o#t|@HV=-ozK7di9VRj? z5>5FKgNh9U>K`B|z_36n8b1HQsFBdl%j#d|A0@Lrov`O|P|^`=3du3Bh3aC{_K9@t zW=^0}hCxHx%A5?I*jcU{>xvJiiQ{@wW6rv$42VZ^=Uz#!mT3? z?RSTPkIXNXOlvd!zSsqY`470#bt%rje)hY^I&C*qETR1pNOf=&Lwf}Tt3c`)0`-rx z3*9JQwb`zd;0(f76mEU89s_=)(X2TcZ;6qkdnPb6LXQ63Jo5otT9&*XY%zW$%2fXt zpNB6(T1fM8W&*E`V)T6*Z=x!a$bGPZs0p78%<+GYo4?$|Yw2Y1YW;oVE6G8uP|Z=2 zwO9#)Xu)2$BLNvGumJ)Wt&QK;VqV?vt%8sFw}u>;1da*j;`9cQDmcH{bd9M|$UBG4 zZB>?n0vjTr{?TmWj-fj_dY0qoeGB%FUCO>c$F<~~f9Y7_4ur>f8x}8fm~=oKNC8|1 zh*WvkgSl?nNXfwj30_^R@!TCv3i*(iegEdltF2wA>?4BwDa4b2P9BDBquH{41OxeI zcnoh4uKr~|Lrk)xS{vTYkRfTHdsXxN1&(py<|76qR7VtGup{~v)FogZ`9Q7e-yNl= zb3AK*rlc;?ez&5olMz&YLZ)e}6m+ias3VX;oeg@mIycNCSgiRTYSkYQ$>mCBRX6(K z%Pq4}Grxd#vWGI_3MVh^LjIPbs2GgS+dq}%UJRXzm+CcUrK=>Y+=@3Z=WNtJV0+cR zL?GBwzO3=h^~FXQ%FQYwfK;QoEnrU5xOOwm)Ti}Qc;Ds`iI;9qXf{vdA7K^!zPd=t z@#F><*lCIi08!Al;6IFB4|LG)>{*_y*~xN`=k8+L=TBS|KINX!^3d0oy2wu5GVFmk z$~yqTMl{`6EXGb_Hd|ELxnV)5Fy5K%C>=#5)*OiC(AC;?Z|ibx!~A7?pi_WyLNtQ@ zP>QkB{<&Sk7juD5*&hDKHb31uiu2H=@M*!$+V`aBRYk^K4WNUDD@arz5Av0eN5FE_ zeW1#*$0z2e=xvrJ@o5L+$u%+>ZmlOlXA;y#IoY5SxHA3X?n!iYUX~*k7LB7WGoY`t zj(CnR4h_o#hZzUk5gP}~2?r1D$Bo~2aTS$+h&Wo8DxCA4>1Dd(QIVmRj~*-^oL$_f z)EmpVI(ZM=7v`##x=~#1!8Rfv@ZN9q{^{tj4N8bf+wDc3!fQ^ z2+_NA+IO<_6aKpAS~DRQPsbSM#@x9^^(;PCvA1xUF|S>9qO-F20BqfFCEdDGxz|TL z!M)R>&FQtQpK7tOM>`sKC324PZ%a7J=>cd9&E@_e(*$8Y66gqN+sZB{6@sUoebsWq zIm7trE7$H`J(W+sMgL2SC~Vn=iV!sJKCcEI=0xV&)sSV)F7HrKy=}gpcI>pRyP)Zr zD6%IRIZwD0D5IVO4gp+%=v#LrClYur`$E@04G-P*hlW1U@AgRSe@(?q)ApUF<(RTg zvs#MP1Ul&6kJ#M)pV2%Ao6H@g9U>ZkJ93ga+A-X}^^U+24ShgU+uw$Vub7+9>LGSem^Y$A)eLZ*Xf>^zM zcU9UW=O&SBJ62wzf_9IL`H#j|J1jN=9n88#Qp3}uFcOhefQ=1**qtPrr}1ONEc-n@ zQwP(o z|3GV)Y-A)a(79=FXY~YRr!W!_NjMq|bU9K=&6%7zL!p(cTsvZ8r4PVI2{UsqJQh=W z$lbGzHE?@t#6Ocu$FV^=rET{rYjU%SdbaJ#GFkkET`C+AW%~3Pu7f9D6EqQMs_r%~ zUxp<`Zo3?%HTi&y?&hpM33QE z&z~2wi2>aG03PT1lEB*B*=`Ez+6nosBnwr!XmGitWPWq4lJh1)<}Tb`_L8V)`^4Pfy*XzI?^LFxnNc~I=29}(faHiRTXVq;-rgKtC@6f`y~HZ~W|kxGd3L75*x zB^I6&4)eb4p0=;3`%MUQYP4tV-eE0FC_cS+ zceaV{Q^YqRZ56*aFC=eHF0W9B*WHOGU=Yq>o-;Gn08~A^DRKih=>Uwuj9Q3IWZk5YBE_Y_#FhK_ILXiy<5NR zi>B#x4frwh=~*Ej#6M(Yn07LYHjPeNh)p|`rX48kuzE2Lt~=Pn-ED%EdA;oMh8*9y zViE=kigvBP-QpPnnJ*`Ys+iel!c|1~!fts+txt%~%ensk^ve5$Q}b~l!ubHc;9FV! zYaSat!(H!ynNYShS_Y>;V^Wk106HQ6rLJ002hKF7&+4vEZ&*bosm_?d{zx@wKR|WQ$T8`X5#q{j0%is%z$TpcY zhlz%7Y8gg9$*nhBi$Z)3HsU|)nbr^=nH=W9e^l*=`lC-fC&N2)Kj+3st-V#e&*g){ zQ-E{PY&~{ZNR#zEvGBP4qEjrcHuKdy`OXV=L<9G9IE_oi*Yh={DO=&g0Y4%iz6G5w z{~u#I_V;QCU@7w0pK{Ra%@O^ExT zoc^cyy>#L{`g*4D#-_cF(tl=L*-Lw`?2b34g4$FRfTsBSSLTV7RKd%N-z@LmeB3U} z>n>cUy-IzNpjDAhH9uM2Mr%+jux|HCZ}AQ1R7 zxa!=^0hcWD4AZtxT|XA%#%}n&cPw%=&TUDgI@tABHnmNO(<2Q9r!(c~^dG#RcWQUWsk<)h~{oB8;eOEw5w`9Wm>#oS`zfc{_+W) zivvW8AP->9^}%G&$#_cQWAH4FqEaXRM_?8mQ69*@w=@}~(MwB+PcHcMoknrbn{Q6d zY=wqv9_-#UUM~-}8^s}s`+Mwn@NrzR%V7%a6W6sPPs%-tNQlJAQutJM+7_^$BIIhK z`Lr}0Bh**&jVcnWYJIj(hkMGpM4A^h@&7oYE#0mvLt?xXk#7#xC}2IrNmBI>i73k+ z9x~=HX83FWoHNkpT%x%|8*}bo5gz__`XwLg6s_Wd%zxm^{p@5-Fv}U$GCByrygZ*OtS@!bdY3I?pc8pP!(yO%Xb@^$+ zK~DdOc?p}x-h>VC4xvy2(MtaD7|=QA#>4R8^NO9%H=g_Pe*UN0jD%bSo~+%!dIRfM zw44}#IX*dP#)p2tUcDHwH23?aSSm+D!N$o<%j~FhLH#Ll99@l|keS7WH0KQgFmU<6 z?nhov{y0XzOy2tC5q&1(TnZ0K`Va^HpzlJ?)=SNoQy1yH=qIX1K)*oS3PHq;?AVP# z2f1EP8P?5zoHd*XS}bY2*ChnvjwzcrUuwp8>{OL^f{*pg2GyYI2+_09dLJ%CKKCXsjydm^Z z?;s=(t^d%@#2-Z%JwU!ZKKJ@{(eUZluU3w5S8v}Mq5PWh&0qPEP36@qdUCNfoPQ;S)T&+tA?pfrE;w`ndVTVhX3GPHas&AE6%zF_?JBcTkrB*(oRx z1H#YV?Ge#EwqTFkBQogm+R zDST&suG9Wp`mY;?zZZjEo369`pw`$rQ#;j<56daSHql)6Hxk30sntKyR=Sf!Oe0T( zS5Uu{8nY$KEuwdxm9r)t4{W3ds0)c=2j!%}2zSD9zQ8{_IQ(18G3es&w{gw%H(pp> zy8ppMjg7Q|GR^kHeR`l1gam)IY>z*5As5;evs}GS{BHL?g_D`5vuYnRsno6l6=zg| z+A?op0K`~CAY~Ep1uq_6pXrbl^IP5tg2nY5+r{6-Y2Q-Z9sAlWTS&>ydbo~WF#|er zxCr$3eayjJgKyhW&PRV)_+q1Km=>l8C&?s59o9*F!VPS>12<~?!DTHD--kHCW*jjl zCiDHfA%UN}{eyZP&wM@e`RVbllm;y$DKKx(xvQL6ja?KS|-$5bQcWjS&(y(a{||J36UR-aC7XHeGTWzIHv= z0^Sehznjy`*B5|m5LXg{Q9Ju8He&-r#~ATTkK|dWu1V_IltD9}51sd!uDf$3Ew6sg zlh+rcJcd%SQ2dCfW=D+HV3Rg<5Z0Br5ZyB+M$VdSa(ZpyP4dqjspno)dBtlm?i$9O zp|Usj*NgmxxdwW}r)$P1YU$jrr`%@?alOFevZeo`!DVITRsZ78h(taVdgB*CqWP&= z7+>oU9WwzGWU9$OBz=fYUxw9qUqHdo&r>fi@Z zONhzf&8Ouhz5KrqBr|yN#MwB0@~~4*`jtNa4s>!*^o4%ysfRhWAG4b5c6+MI&1P_~ zoD|5gmomGoIJ0s?iMt~0S#}{g1Ar!AYNTn+7&3kmo&$YiL+~IG305yj`rYt&nBkXZ4YwoMNW##h2>p3^h`|rX;zO5! zS6V5EOFO~%!TQb8g%1obSXL|(#9Sx@WY}5lA(dJg)p!s6+MTO0>_TL`@u7l6qfPL& z5Tn&NLGw`XZNlr;1gceo|42_>9(DjaC4R`q*x%<{Pja*qR1OR4G&dG87M?7gk@`Mv z$KgJ$NQ6Zs3kC}T4Z6rIhZ1EK44xa?epAF8Z>f;s7HwWxvRQ9u_rO|olk1a4HI|ne zdfpg(_`nzLKkILPms9SA4_nZ66<+9^Svi7hbpM#XZMVYfm>v{p7d(Kz8;A48-Qq7^ zyTjQ|zAT`m)$=gLH_zTe$GUL#x1?BKrmznugp&9ap(_CTptoZ&;_A9;)U$7NM%VhQ z@_z|Lek|U+raBs>@zCqcN8)e&%qnFYPF2bPc#++%HD& zw4@8> z=*uKVE8aCR)9kDqQ*lWlOb-lZHucq1jjuS;H(3h>_Lv9=5e6OT+WsQ}c zee(LehS?-1pP zImJDEU6h`N*DQE_ii#d8if}~u=m*>|(?Vz;2F8TY`h9r98ktOXH6dEI*K&FGTqAEq zaHYN!NvI!6TSE~d`g^>R{|{l`0nT;%{cmL@TOlGdGkaI|h=w90B`Fap8D(Y9vOuIqX9bUo*~@ArM5`<&O==yPCG^Uu<92wl|t z-BBSclr-$HDt%QWXLFi3{~j;UL3|P^y{I`#!aBZk(kQ>6^_|=r8=>^{i5?-` zi7>Ar<aXWE;51*XtI!TfP@p5!Yh8*%ADwtn32;KH2coVa|38`#hkNhkSRGH1tAhbwLVT z3JLw!U_Y@YR>o$Oc=s{+`;%6s+jTGP8|@gR;^_PUjO@#LBmi4FfcCSVx$A!1`Z#kK zJ~?leHSI4Fd5rnVy^#qGwmuVu%O9F;8mw#6gUpj{o0L?C8hq$ZtiDHi+-{v3Dpx(8^FPXR$WCXhZ39 zbx{G@9%=2P3Fz5`k_O-2qF-mp9?>9o?_aWJ%`BM#d;GA6iD$40l8xTqneY$XG5FvJ zS{i1;BHC#4EgD2tYxC~5+4V??gbc7&d9?}I;vO^7Elq5qeY4hTnk z)e)A;`+M`k5bl+f3==J;1k$rkhT+#bh@CS(&*GUv|511as8bm)Mt>dmpBtF3`hT9X zSn8esgkgI1r)z#_c|e}n&vPSAgN&zk02Ay_UP0aVFCX-y#@*nXKNs+_v$oDTnqTV^ zhXQ`F#I3o!C?$VlJ3*Q6UNF)}mU=i1-MMS4FMB2L+SG!G$dB$VhajWo`bWoISW_Q= z*}aF6&(Bx~SU?2qFC=Z@sI!=@@qKPwiJQ#H3>={*qlsp>3|?reoKx~ieHZyocHkd) zgXI(iz-Bl&j!C2w32{HPLO0T`i+ObYamLm$5s z)hlO#Qo+KHaa=v*EB3nj)NI-5II0$(ly21&zqVupH!E~#K|Qwbp6KIeb1PaNyrFf& zQz{!%v@c!Ywyn`uG6jM-6$Px31j$H!SPn!glKfT!Idce*aTF!MuN0v=2TLe*~y|@{K5#VC9U7Lekq?RDiz$c zS2Z$(>Q^Y>Kg^N{N4(Z>4eBhovz(Pg5?W$+8Y7kp6ft#A#HR@U@DBXF?Xk`9DHQ1T z?R*q8{&EBX{WZo;3}ZN|`ZQ2D+a$cEGxQ4MR@G!~vrQ@^Qu`zciM5J~kXD1T_yWEl zjz%{ej0$Y03Tb>IJ{)`uEO~Ag%wy*;u47_C>Kq1)WQqay^_ zl(1Cx1GoD#Qc&+|^Dnw1xv+9-cY_US`tY;3%nWDNVFRJ1u0jGCdIMMTS*mzB9WZ$y ze;IW@MX4l&^x%)7{7-+(zE1{zP_1CI51dFtK@>2N@I4z(?7D+Lw zLUJSETX9SJDM_!}og`{4zR^AE9{Bu1JrTA!uNUpTC|?JQVOx-pQ0t0V_2H?+s7?Qu zPZx@X4h|aS${u!NabnCg(WE4<@t-I^6QwlV+C_b)#eOuEO~dD*4SE>uOxc8Rj3x0d zzl#3dtHe76|AsJUPtOQvx?yK{Us5)K6a>Jw(9-yTGpGNc)#Lh@YH&K;_M;?bNu7zs zH9hZG9rZ-jQ)KHUFZ2cc-R=S^0pW~*r=4Q7dW@=?@ty9FaV0Jp7#8#FbjtRKyZMmi z{Myte)f3bE(H6jA;viR0FSexe|4|}^zBTy6!H1)KmBVjp8(rhh7ZBtOEavdNpdxhH zSzTI9AJtkWrdo`(K#dQAr!`FK_~zNCUB7`o`q=jsDhzk~F{9pWTs`xvswR-ZoqG`U z1b9f1oQAAkl*EDC8Y3T&slo9X?wiqgq<7oQJ>XWhzqO|!J`>-i2@wx%K1eMAqZ4K9 z{BlM-*^IzaPVmov{Tyt3`@r`%GVhQvc0cKjvQviD-93iSW>!nTX#Zg-YP!%6vPtUV z9pbtL|DNjDoA^pa0(shwYsd9ko^Oeo1$6xA$#MAP6_yWS{+YOGnv~*0Sue$AGJn z{~sHziPfi5_qu@&DsmBT#cybuh2YimYh}DKU9#7(@E*Ilw)c8+iUd?#ee`&3^~%)h zlQAnL_%3nkIbU>fgp_vyE3Ox#ZjJ0mGex8Byl=CeXD@$AFl%~>vys|&3nFs>dxQ|x z8&is2N2sGujkl7><~xnjXUxo=I&tFn72lYKtG0c41$^4KgrEpRfx5sCJw?E$nakC< zkZaETS#Q@+X-D(dVtTJXZDZTCnU>b4=;-c)IU@&*j*=-MNHHKVO2jzcjG;!3?rx&Z z+V6+PF7)+#+V$}j(SioAjZfPY(1BU9?^8yp&;lfb5AJJ3Pax&jtNYRKE_4mOEV|zr znpZlrxCC`p6*ekW2eq<4QR=e$~>-J8I>i^)+ARx;MggMj~q!9Ric zb}LKKx>t7FWm~+?nl`#~*l^J9?-dt?S?cu%Lga;m4CU;YG}nM`U)Q5vP$^7rLV{q{ zX>n2&%>U@4*|)IFGnp0waELxLr%t@0lh@kl2^gdx)c1%ceq-#16A#fR_1X%l2Cq?LKnNHVF?vg+A= znQ75@YrNjfZ17!+D2N@}DT#UL^-R;-*pp){zdtG&w}@!!5ZSD8zn+yrlz`FSSNMcg zYz7Pfph9906T|5DmY)?ao2WbQnqAECH|>P%bl_`?;Pb(v77GPQm3!}U9|0XeJjA{9 zE*X8E*BUdXJSl^8sLx1X@MsllckEQhei**36x1js`iA-$Hqa@+a10bsPRc{uqarQ~ zW=ZC?&O5!K9$X#9eQnd^8^fK%Rpme~#&E=6|6c10jLzL*G-KGa)BbcnbT{+--VJvmVK#Z8Pl)pBYs zWYH_ojUn~%1AYQFt;gHS`)LVchovw-3Q@B$;1!)<&oq^rEO6aeujA%fB0WB--y@D8 z^W}9uQB7UF5s?`=J~T{1y*=-vMr>0H^`aAx-|)H*Fpt?R%igqLJo&1WYlnut@zm`{ z@s7cuiec_Ff}2(<&~IUoQBqx*B$qrkNXMK`@=~31<4Ul%?;P6jMCNrE*2TDFUU#}87ZE)F+<2VJRH#;Y)o=Cls@O?VyOm3jB`QyyG>ei& zz{?VU!@IFhr#QWFpnoY*-&pV8=&1UQdU*`^#XeFW+pQ;!^|()AwWSQM{esTA+e3xDn%c=)f4I)O6n8_ z#>%|pb3g|^Af&PMTVy@BZ6ZtRzUQ8SMEp;z8IvR2noinv-oayYFDSKR5Q*DZ$=t{D zFxnY~TbJ_CZ*}v=vkQ3D8fVv%)um%6gg8|iF7C8$ahpfpnTW8skW?04!y9rV`>w9p7r_Ggp&EpzJO z(A2s(Ta9Icx7zaur-^bGpX+4V{LTdsA`FG)NV-q`Dls7y0COUo|Hxc8*euG380}H# zG2Xi@8E|%tWm?_2pD|hL)V8Ubjjy;+AHk;xr9+KT6d9`jl|HSy2)|tJx4v1d4=W?? z9mOxUvQo;dJmQg10&y^g7g2?$t}Opr*G^ zZa5!6-PjbJWri&wbtvz=y<|npWw5VZSLK~aYrphJF^%yZQPNO8eXc}?hT!Uch6U&x z#EAG5jOJv++=}vM6^ox15(c*_PtULK?5H$w*DRV`e|syj_~CsGpxdw5L2=~P5?bq| zn}?q>)Hq}4hp8t0Rm!Gv6*E1pM&^bo&BX!+EYDF$p99|!c()YvZFFNUN0t>o5_|V@K{27LqNpV~?H4R_mc&ob1`@lEVR4TqWFgJmp zdOHa{$+9%wH2Y*Ty$Q#&swsKL^{+&>JS_1G%pT(X++zB7bioe+`5iDc^WZqTkJ{eM zYpTg~#uv&x+qe?@P%HbAao?MXJ(5+E^2^2sxH-ZQa)BN#(B%4n?jI!CBL0hz=^~3& zF3R~`C#g36p=MvleCa0}yRz>@p7$nK>(#{p9T;th4|Vsbcqu&O%ZFQ{);X@@7sCU$ zEfx9&1Myf3eDst$Y)sfiSnPogI$I#}r=tulw{V#HS-!}AsuvgS&i%7_Ti=({&88<{ z=3T%OEcq9zgbDBhMWF8uYM<>$LOq=Sr)+#}!JBivslHEcdtl;bn<>*9J+dQQRc)Rm zig?Q?3fKhlUJzgTj{x*~o)dVQB9W1n*CPeAxK+a?s=D1$AH15H9?0|Fdqg^Ez3&W# zL~7J}W5`TcSZ`_W<%+>2$FB=`Sk!nlG;V51yXUc}<}c+_bJh6=h5myV4?_cyc2gB# z>mc60bL~Tn)55CBG?*c|@2~b2znjYWr@&2Vy=0>ukt{Ch4ekc$`h^lOm7%D|3d@y{ zkr89tZYEZ1^%x_zK{V9QAT0 z`uP+lm5-F|{E=&Aipc)BdiS)vT0`JxnPs-7Xy?yoh+{ec)<7~E(%#1P2(I1mf1<6H z)^$pCOlFwd{8TN|qfpJcvu_M%1?o@nk+ok0I+15*y2xF) z`<2Dhe~#7@6WG@Oqlo4!aj^{& zI%QW1z6L>lM5c!v2}>iV$?VDNd{fBT;KZnMjTTFkFc1dQRwE*N~7xkuDGxqRk(Hqe3UL26Ei3(&f! zvLQX@>5F)*F)n9TpTfzj?bc!`B;FLS{yC7V)USVQ*0<+T?P|O+ zR2+DF{33o{pWxa)+JkW}NS5q)3tFl_$PkX3rY34W=N%h&f8w!)hHN;YQoaFJ%W2mx zdTSRMm^Uv&z4Ql_N)7vCtd-;8AgbZ~wbLPn)zY=sk@Pz8s>jY)zgm~zwm}CaphI~G zNTPIO`DZlRzMx?H{Yg7-BbRzuwzInT31iuNYic=3*Nq);EGY2?KpQA3LSJB%l5?I$ zysu6ej2Jk|EMeICu7nw89g`s>=(_ziA2JNC*}6*G;Y4>bj9guTqE&+yXXo5yzoOy86<;X3R-O< zE`fqNpU31U2nAKIvI(AZ_s{ke&VF*2DE{PQiPqi-qyBk71$;2n3guRR4_*5Z`7||+ zSwty^x2*lM{+mPGch^bhvpF5S&vF_moZtPZT7d^5C=a1#6pD>SYFU7RdK;jcdF)DFlS1X>>Pi z%KHgV`H+O$PF_vF{(i`*JTU^&r* z#SmC0`)OjxafTpGTj2BL>+cu+nD^GQ;=)@094+IglUdqr6}{20ntqIaUG|3p&_QJb z;)wn}iN1!e`^6>RlGSnRLk{Cu?6l8b;aq*ZV)=z|?v-6#^ECnRu)v^Y$mTx~r$gIl zb}`M=>BaYPHK4k|P>;FD__6-AgUZ{NNq4L@qK~_f-VzrIWKz6o1dwu zMK}P(D8f)O)N?2}YOv&N^E+9g^=8XY`lP$JKe<`0n{Qew2Bw8y=MBDdTt9>1z{4Vr zc-8{S(dRO*#;H@EDk)ba!hWpBCgwxAb?J+_9OfH~w`$K6{wi??y8ZdpyYT?xy36Cy+t4OAN z&#ppw?}i~6pfo;+zM;<31^PZAM!?@q>B23U{(^GR2#1t@qT(>Ndqg|2d^EJ=eP+F3 z%@Ep!z8Xlok=Yuwqu5-l$E=SntDMrl@?)5|tJs1}A|Gkf$zIGTPH8S_rZ?nR;$qa% zD`-c%(Jn1RZDYu~y*T5Aek`GuM^m39F1A`bP^(K!dM{~B)UO0YZEkv~aITyi31x~9Wk-JmG3ot?m+SMP3 zlbNHEBK#S%)7QF5PB*%lI5aYf|G9UzO7WNIx6y?68&_X${Q;CE2UV&_l5!Q2hX(86 zii{Gurf_OgtKDh1W&QY~goXh|_G;Fk-E#$%NgbLNpi=}?je0gK5Q|5&NaJplN!518 zXymlqYPDt&+iVPH>EtwDuiml3+nU?2AR|Iv2KI?!$6ufg5UoX>P3SKCfd8IDZJSwGsmqqulT%oE^r{iSyaP&MK!40-N@;YmBJj>!viz| ztxFEB!F3spMlfXMF=EItVcr+?-Sl?CkQQ>H#E1pI2qqDvupOY0qJ#3-(OaZJM8yPm zP8zc%j=Q>5<2}i|xe>*z#Xgy1K+U#-9Gn&Ll}#skp=lxJNv;Tyue8e>OZ?>v;VF2T56IFYJL$E}#H?NKl^_9E#=#JrNSKI87NxR9d)Bw`oQGM`u<6M>{sqIY}XDbC=?Ps ztiw%CLMs*jCu;<$81BO^cb+U!v1x9`->qryV)JH}{UpbMHQ`gw^$ zv1jj(Tv52K$0-v38|WZA7vbiF9yC|p;&VU0Ii3Bpz=Ezio4w~&`-=Hc-LVZa)3$-) z#*9$NqY{>b?0D2O{(yv|Kq|TwZT^~$P!%B-Be1zujxW-&bam7}YYLjuadKh=~(ajXur{kAV`JZ1IL?JPlm++-vr- zAx7k#?znHSB#cmML_VwpI%t4#SeCwqrd#!?=u2!`+?-4(Ji+?)_xVm!s`J+r$65Dk zE;xi#P38cdJS6d>l;~Szaw(h(U4l~QYtJ`V!jo8Z{UQeLvWoHklFQAX;+^te>;KmY zN=*ikJQ6osK};N=^ZiBWpt8ID^8&Tqg+GhSZB*HM-2?B-N`9(PZq>+}8vvag)WV?d z;R_Nih3C*%Z_%ML^lbv~SdL`lV%o#oZ_^|!Yy+qC-*_ny<;1K29rW8mY81X8BNk!3 zq`A-e7wwIS%}ge@-13L-u}yWaNOS9b*A@tPGn$qQt|>Vgu|rJm1hA8 z?~Z#t@x~XPePvGIv`Kls2b8CrkRW2)xJ;n1F?^R{+0yLgJ9E=RI=rdg-e+WI1+4C8 zN6`_)SB~U(t&r@~LHalHd@@tf&z0jfiIDQOZnFD@1!nYl+G?A3S~}Y_E>L|}&+QXj zks{nzy5Pb@fu==79Km^%I~8C>Nwj-+WXs%jq@cq1`MoKpe@2U2uCa(JjG(jv=pdAc z+}m;tF{=F-7S?qPd59of$7JN%4HKV$jbq&1_qon_) zv)r#{{{F%xHedes4uwXPJGRVf!0SV4<1MP_d;VpsO+jN&FL~?eNOVUhq3AP%d{Wyo zl?*R7@SE?qmOyG2R-t?uQT}h~ljBRyTRl0)h0!qVO_=G;OjGpbgIS(VJHairU)}8c z9x_OxM0v>G1QQc7LcHdb^!}dz>xc0`=a(PsyJ9?9BrXx>f&V)7=^f*D4w#poI{DtO zx$a6(ZE2uADSo)VhNDJkj+GN`(wyk!f-h%K1Dia;ldQi@gY{v*8zvWWiI zpMwuT1a$oAA_$Id-ZR4B^Fw+p)yFK*jiMvuSYo+GP zYg8c%aeFs?BC~L<*6ALAxP}1+NQU816e%iDCcVFPq;&IOvx%tF{{N+bBe!kCnWt3U z!9LGVzDHW-VL@0rhlR~>!8?x8UGw|nKS_`?3r^lc1F#WEA%I79VRGQ&vc#gMNH5L9YX00wiG&8}%0Z0JS7sVxsxuk@oz$JK0sB`{LuAo_(xgZjj^1xBn z$a=nbIReY}e$v~UI=y`t=f4isB_DD{QFHO!@$1S_DQi6sL@Ss%3kvJ|2cHlCnqExLCMl5+2UEh#D+8bXc}A9dRr zD#r;n{)&w~C#`ev^>pmi4k2#oHa7a_*+p495crhd+9ERCK7LPnK`OfrBCL1ZD zGohz!dlzVAV#=0kHC<(*!Z%m?$7$i&@ymj^LvgK>C))FHq9M{cEi`S^IgI@?Y1|g4 z@V~AKl{B4*;Rv&UL>xTu0P!n;{zkB90a`0om8tx$>&%^fef>n`Di4j8$=gAA)b;6edZBFXYO8)(nN*{bHKrW+5Q^F(eUXx zFsy(KBzdFO`+zjDfqVK^^K4`xPIYO0G#}fWVKME&vA0!5_d~hG>+)MSpLe_khJ}Xm zNWdm_8m&Dn=#u$(>*f^7szc4+M)Hv4@2aK^vAMmKui)e{TVdXR%`l7v5u@*rk~mn; zn2%6*oArlzrc9v-hV;C`?~4pHTsHP;<9yEvi7B@CF|#66!k|#i>d}C{_jZI%*$H1C zy-u~@z1-$DF=TKxtcU$z3wK*5;`_iTr*W`H zZ*%|huK(^Zw;A@$R}>!ce`$bD2Kv+@Hd_@Mv~}CLmK4X}E^6cFSzI36vaVVx8<5?3 zt3i$9-q6}vKLVJ0zp3W|Xe&JGU$uT|(mtf}gwB|o-H*}9B0Nr>36adYEUm_&7=_j2gXy`>m%Z=lf+4<07`f^w zz*Is=Vn>&qx!25b(s%=7#>D2dXO@s!#Zq2s3tQ3jSRBwn_c6p4S=>g8Gqoz)@MW$c zUZ$twf5uPHhW|5?Qe@^;x0ZHPGmpJ;?G4aDsVCz3h?qg2%ZN(XlJn|}8nfhL*1SDu z#YTo3*5z4e%JDQ0vy7IYamnTe&7Kcg zv~B#4{U&};A8@c-t{?jI+@wCm$<>VJerbySKGi>-@a-IjtfH4J_l4nxh>KW~V*s`w zIEb)y%hC1Ky%$yZn6wnz5&9(Ng>D^M+Tu=i#D7HYb$(KF!^RwfOpZ=2Mmv%C`mBLPsCZlCn z$%awc?_7+@2NKc*qy4a{3{x9kDnSFXp53ZBkx7@4c zEo7CNRIdOKDhG|0kZ?=g3i|nlohY{bQdHsjKz-C-V$u$j7H3HUfVF4qZ5O9%jR4%RA z{`32CNh^I4&rSxSRQbmLxKl2y-OA3mRYKVGtDG(Jv)=B<1RGKCFF$=#sG*ET+ z3vvvl^@)pQGst5Nl-rE7BP#O>>%L>O3>rlTc!{@#eC> z-g5BoV!LtC9VrY~aes?|=NWbevCC;=Ha8A*wFm-cv)-ZaV^}90H|GUkET5UlfSOZ+ zz}r;uoyway={6n$N=;iFXZK%|APjOpc=dkeq$pGA0734fNYsxL^7{Z&qI&XFJnrQx zthhs?A1dv*SK$0&sOPEhIElK;bQ3T3ZDlRfLm|$kLL5hOZrpRxaK-hbAHEguf*$(~ zS~|8LVRH}2hF(d5uo8ltRh071K8jA=PP`{}-$rL55|>(~CY!+S>F&5se5KjNSHnLG z{Z=EF;gtZCMwD>pG%2bl4+0gR z0M4V((G-&L44nKr-#>g=^)D?i?e<+$l@nJq$?RL*t>?AUzbcn1^9^kQ+T;T*i82Gq za?!R`+-`S^bQFG|{d|Re&EYJ9jx!1XzS!fAoRnFOhxdOqs!`XhL5dTNe^zPk) zO3F9Yoo#+EQZt@!*EZ zP=RSsf1#y1<10Mo@2nvogRa3>Vsb)FZ6zOD)9}TqY zLg!`h?_Men^aW!dh95&E{sAX$foB(adE(yg{?Z|2-tJ}(%UpV}WB+t&=?T9J=k=Kk zRm(g*bP_6s1*j|M&;h75my_J~OGKY&w* za54Q8IvKA{V%oxz`s3zJ36hNPXkppu%&`pCn>sJ`i;7>@c2G-!Yf$bGM3?WNkHbVF z;ti8iNM(O=8QsHE8slv=b&uDBh33zWY0LY3Rx^g>rx0yktAe^JkgmcA*#G$ljT(~l`9p2OjJs)xFO@G+IG%}! zB&W(0xGT&=5ajvR;{>2LF*#8&B)&FMiQZ?!a#9kvY}dE6UoMU=#Sx-Yx*pqJQ{LTH zSooZD))oNTp{4QRRPBZ!G@U;0@pHV_v6G(vV4+nDX*L-SS)LlTaBC16pymrbZ|Vnh zPz#DY#B7*PfUxClqx#mbm#rlQuWCqpd>|$Eko20pa^E&7j8&2C7QH?n&_O8`q6p%S z;z+KVm5)8%Hue(xO~7X zTk-V2{6m7DKPS4_UQ38|nkAM0m7&2YkGJnQRw6;r?2rCL3A(8!^gajaP6rbuP38O7 zUT(nnNU9bu{3izU3Twk#?5rr>eVAh;U)bIEkD z;oqfC;jH$2k1wTUwd;VQ1JK8hG*DPOYS|}7FV(kl{?m2Ke)oI2mF;I}^3_*VBZ)I} zBbK%aS4u#T%RnzYq?XkA9a=m*eedkWu4&ps(NT*z=*jcd{R{TX6W!J;cRJa>nu|0* zJWm$nD58+7v(e%~Cd8bMox0nXBKh9WcXL+3G45}Z9$xSGZ1hTxT%W zZ#&(p`f5R_=85HS1uyvD9K}Qd=J5GIQK8+HVq0*TicsfG@*IlU`FdW3$YleECeUIs zr+1=9Zh3B9d?Wjzit2ovG|MjVB@Bpw@g)cMo#uo7t_)N2u9q|-H!6&kHj3S-p10r$ zUtI~~n#bIZW>{l^;2y+NA^i*`o+FNo*VzE+*~I3RE6dq**8NHj((h|5y(y?&`SucV zPsQ?VJM04+untfFpa)5_0PAO_+dVidh~iV`11H~(?$!3-!F1y|ClR$6jf-qgYoCDl zl82cGi1=ECv?(Nh*7cf=ZradO^3DziM=4FSWL}90SHgK>at@)(jO)3|4*`EcqYcz@ zPMK(QSzhqK=Yq_rgMYcB$cq8S&uaJ|>k^!2hdAz~4pNWfTn3y11>cC?t^$udA}yQQ zy-hYFmFd#z4UX$-&tTnf&nR{NqEXSdFz`*{9Emo}5LBe@azn?n7-=1@r97gD+h{2GTJ}b+JkEudV1PT|6 z4-*3yb6?pqN)sTxkc$qSe3idZCKOKj8+@OxhriJkSAGj7M4@0z{S3W5r3pn{sGallCqu+;rb$}F5 z^AD>Q2$>eHOwd0s=al#}K*4iU>XKSea<1TI*{jF%3YldO_kKrROkb^^@$Kqq4Kc&) z%Qy`iL;NpUs~E?gW*5COi);l}6aZO=ie_X$tsf$?q|SMsmG66zT0vhyukv1aVp^kJ z)iVh96vu55+fWM`i1NtG3&7angTr6^PD02Ed#8hq{#SMF;b$Cd9_0$IB6!2i`+jHO zo=hZ0ZY_TcYvtgJJU;*NewDyuW@>R4 z$}c<&$K>ZaDL^fYf>=RqVtp44EFUkbJk6Hqzf}G!^~3BBUAaNINndpyyH?i9m#)=g zHt&H>9{Nn7-fhHJ#1+iwbhuT-Ls@#jB~|6^S0|dZGq>*ZZ@jIbuNT@#zjMI>@1(-j zY<5~!N7us>6HZl59IL0LTsqfu{4P1eB2@}?N}Xjyt6A~sW47mAYxXgOfGE;!B(@xV z(&>IU@k|x>`CnMHrO|wIAAfa8`O25E^^d98;;rmgTtMh5fKowR5U~|VyyJgBlK1}-t2i-hH$lR zbBsw}k4fElmVke^RmZv}hUhT18K&?7E9_^Kp=8$Qqe)bkIz^R)HNu^n@Esp5$%pUu zMK9AV|CZqvd5t&ui0O>mzK0n6r6`P19s0j|i2q~va193^fSP?+eL6*=Y#vu3C1|5> z*n6G;`}`$c{BVigNwv|-SNos(9iBh4uu0&o!jDrf9;#e?DZlDfzilh8XcDro9UB<@ z*RBjgkY5h40Lr?X{)ak$_;5*#U`s!y^pseNdNH*pMZMvh&iCY-D#lv3-gUo_d;!@S zVlqNdwQ|7eORdQ4!~dJj_iy81%j*Z(qSeOWt;oBn+8blsSRykeD4s-Is1kqdC*y*< zz$IUImBTHYc}=@^2!6m|&j^@y{Cw4il|r1$kzBOg;^aMtQsn>$QSw1$4-)c?nnANn zP%8D_UbJt;3>N;cmU%VS^fv=@3j+@oEZ@k!z4k;6BItaI(C`g)SAhsThEKJ%EWP2x zx9H(F)lWmNp#D|-y2sVC3c(y5_i+lVb(2Z<;lJo%JG23$GdSp%{5Jh}f94b2Klv_L zF#qv>b=m5ZY;4a~Zp}&Zp_B-nE-KqFV{)2o+NM$4OH1pkSN=71m zZS&JawN%pELeIYE?H<5?=<|4Rw0-XAULDf)kDgE5`w`2AS^w;d&{kUK>zO>g<8=Rc z1I|0L@C%QSV+n{+e+)(!G*=9Db-m5n;(T$MxrMl(V~-j;`sXX_w6kx|*F01cy<-CA z0+iGvMPG zrC)!&vqVLzwoEt^ceP>h*K#6mU2=&R%j~{^409Jznr!GT8b^E=s(KyeKv1mC(XjY5 zW==(?bS;%Ms&@M!N5-w_yR05y&Op~RM6bsnrAcsKq*tzXT+%m}wH6jPOgpzFYf~U` zVZB|${7<(*#KH8)dl zA;XgF8gcmkgcmWy$@q5xy-nhIoT^=~vKQh(EE64G$$OMd<<74fXQOkAXjnNjz*++5 zvXCIc#sk6Vmq$oAOX~L9`Eexn)@KEaOqmX=^U~A$t|>yIgtz$S-z9^{fdmAkwldKh zjX%!OoT|&x%ToKB$JcnTBf<)YzbwUf=sl}7=8tC75kuP#<;}$?QkN{+&R1<1DJa=uahf(RSaHdxsyEw+}zNZ}F5$x+?4^R}9cW zcRr*lpc!ECzOLVwfFgeaHSSZn*1c~((cR*j=ysDLCf@#Y_Os3pHfhC`ulFS&3?W3F z%W6A%pJk)Xm&4ShWaCc6I95eq-AcTzenp|wsQlJvX$pZ4WPpprpvV=GoWXz4_s-u; z%w2QNsckfb=IeIE9V1sFL8DWtiaSnS<^=IPanL|Q4AMQ3_1+%!M9mR4piKTq{V2Tm zZ7yez)JKQejAflt!?UMH7X)7Xb!-Fk3v$7cp4&SmXmM%a$@ArYfj31ri{oo@)`h>F zvB}d^T5jIq&oGlusNAF3H^0DaLs|DpNT&`sm)FBSQ)8LIg+Cn9l%+%7UzK`5AJ-?P zIUG#?T=(m-$pE0+?{k4VmoD&nAUO9?Ezh^wUyN${`3$F4=-($%sAF+EYaaK?=6NG= z(r2<5(o#jKhoaG50m_dp-$qDS%`RBots7$^^z8eZEb^}xr2-o7yyM@ zCjzPP2EMGDIV*_ilCd!oKHbA>F-4>!Xl<>1eu+X;XvCQy=_g=2=%93%MO+8zc1Tw5 z>MB1GQ)aeNqR3pNMXC~$%$ag$3XhD7&5zB7_zpXd9s&3 zpG*+x9PWHL*tMY?V`T?H)5M^0Xc4VgInne}MN7RO(?|5-wTP2` zE*e2LjE@-f34u;_KNaAB?l)3k3CAMDR<<3dVk*Gu;-~6E-lZ>hDzEwn_p#e#%i-94GYVolDD60R6jJS@zS#SLph@@C z!ZVjGO+3})Vyp+o1H8w`RwQh9D)m?ZaRIhPVq_CX9i}ca_&@7v%-C|v*rtxBDiP{2 zuav3uuXTxUBNK6`DuPh6BBWIywHvOLNLng1rN_W<#>bJCCw0eg3dUB48GkO&$KDyk z6+<4=N%{cxp!}}YK8dmgJUT@#YqwJFttv~H*-ZV67iLoWS)U?bl*goVC~s)49CsfM zK5bW*v8Z2tO)vA)5CuWpgU>IhMH&Z~l>Bty9Seh4M16P?Qlkj((YXPSn|GInsz6|* zG^{&%%{l7Iw=+`$estaPBaSWp5bcqJPQ!@23F|=ot|+9&c!cc_|8%f(lr>eI|LDy( z+ZIfV4mD8O2sDQaOW6lXpVx^nc8zIM_U@sJo_AForF(LW?<^&D{(1B5{gtz66?Qsm!TIo>z?Kq5+~nV#k)m$K!(%@9 zeehogdyXU7Py48$aHxI!(3RuVHEgV|u;X7w@Wx2L^?#|e!n?UGy~Dh7uxI%Hs@=E? zoJY;BeO~m&TwkoGiO>0;ZTu%_eusvJ)_xXa-bcvLbsI?Ts*jjWK{U6q6StpXd^UBNIhQyK3;~m2 z4ntpEkPn2I<(vV^)DK)TE|a|bvE{+m_WH+9?Hwb-DfWBnj1vy8bAo|R5jwG=jFpxt zl*ostL%xl7<=M5n`n%(VWHIG9|D4<9jP#@QQ+WpOo8X9Fgnrb5kez}ei-KMth^9!H zFzdkW(Eh;qs8ryU1Rb@d@wnTyXAYS|)Y^}*DH0&A2erfq5Q#gA9=j2~p{ML$s~eJ! z@mkcGj&{w!lPiH~8AYM3<{yG8<@a$bKoOKp*iweZ{UYC&OZ~=a&Nwk(Y%AAk1~6B}6ix+DvArgJ-0gMf>d;PRmGbOg>=Lq95>3+0TZ6 zi9SfOM?-W4*k(wfcAVKSkQPs!ECop)Q;1^fs#Wr#_hbA+$3vy0Z2`etdT_{GRh za}QR3&e0Bjhi{%qa?XKuTs0JuAwa7@QqjS&jOC-5>x`qi8_BVclDy&JO|3DX@CAKw zuX_jhQJa4I<)!;7qe#nr%xbjr+OpO&?0OnUz= zcrL*{zZ2-79}W_&`E-=uUT})Y?ThA%jn6#fXQZAz`tts%*k#XAo4@okioq_QMMa@Z z2;!EL=<9AYjBKs%aqNa?`fezX%BRx(s2hc*~`?*^YBkH?K zW$I=r!pnEP9xCJGOUkf^yws z^JB=5=LSN3-MZijk_BrIiC(z{pn;OJ8O^_R4C!WLPG%K$W%VTI9EIx58PW{9lNpr) zDY#JHA`81j?(J|QB(O7W#0$oR_ij{=sig0jIltYaDSwti7iY_|;YrcRDE}G<=;Zki zC*`JmLi33po}A}k+KHRep9dctHwwe|3~n#NS#KBA+g>ubHflu)bP9rp8M=Rw94lDw z<{VaU|BZK65@O6e13%h0T<$1b+0iDeCR)|^Pk7S;=K^t4@IV~!WjGSI2PLp6mdLui zSHMm8T$n(Si-%jPqA(_mXdLEg{Js?+_J89R*`!Y8oq zR^ctY!2V3^{lc(=O-o2ZqJ}I4v@RIWNFT9j5462kaoH_DWPC6OCQ;pRC!|KDa_ozNi@O^XIq+?ih>ZP4?O97V7cSeQ`y~$0fXj;e; z>TxwV{%VlpE65?4b#qA5aiBWUMYk}1v8nS6ft1i`OfQSk%=U*&%4r4}0WBNT(z^Vx znj+L*p@iiW1P_p}d)(8x+}mke`#iGW4r3}`?Y)X0)~_gC_E!!eF)xmDLG)a4f4~yz zG`~e6aE=rs41BaWj0V^k7~GiBj9B2ha`M8*#(>;X7kvzt107v>;P|YePb+n2VSIeD zrOi~G-JYNc!53Ky8w7MAXf;f(f@m-C0rOU+}3l8^<1D(LAi`{cyHfsRysQHHXdX84Hhh)2zaJZbh#mDNfcT(E*+Xp z(X_l!%|8_q&nH$5&1#~Rr{yZ6Dvd-29{}Bcr(#qfFgy*-$qJcrlcROUtJ-lpBfaVk zUjt0#ajhaEg8le(doJ;ntOK0_ObH@=IGqZ86f;SpEbWjVekxvGsjL);=WAy@T- zZg6!(&457lbOz8VLZAjEF=MmQoP0wAkHf5RbgMkACD6?1*l~F^3-v_3jU-Vy1zsP# zEVlgt&xoNgew3}G$)9$TQ;gPT@r=%kH3im88@4bzYAL1>#s`GshE%tl0AND@awKNZ z0_yRQlQ++AMXtD|&i!Lgs`+I_IhRbyOWL-&K_5)ROED4iY2SS(0)=V^a-p{!eJYqY z@$c5A-CQ4=T?iaI!&AvMEJ@9$uM+AT6GZcI`DrT9$qGTP`vKj`kzS45$|37$w`SJG zx9YsPc&&Sl!8kqfSod6P@{RfU+vB}JCkJ8(bt+@s=y2I{=lKs@-Q|9|Ay*Q^rsQmL zhA8dWC0DBRJNOLj&T{+$G=!eEkac9os$WTybdBpbI~n9Mb!~~2sD37RNq+A(Px!9NtBV>p=FG%i->5b+;M38W0AmAQ z_o11T?TKcxIBxnb=5#&dh2qe{V~x)`Z{gcsVaj4V9jtxk^0^={k$qGIvqwsOtJBo84)(Zj_1)T7=Wn3Q6A?!Aik864aK zk4PqJUc@|`NDG{~kh**AVUX5a@F(oo3L??wMWk94)PXk{t%!KNi83kQkXxW+H@0h2 zl6k1%zu#)A?DQjMtJi@JggR2K`st`0yk=w7A0c=5#}f+XJtq>`n;JbICU@&bkZ(+^ zUkqO}1~;CFET}saEQ;zNCKp9DURvYWRKuLM5U(&7%HfPO&N6<_pSiVL_4};HNpWIj z32gG?BET+uNN>B&bZ}0fiUo0867L2QWXRwy6@3dPj7oYw8Dkafp5wbQE z;ng0nXEV|Z0?sqpBb95S*eT0*LuKk@Y4CX6(@tvdjTE1pajz3$_Za>jz&?l@9?&_v zqfuswGsUeVhw!K5UkyjiA1^QdAHvQuDy!#<_mnhJDn}(H6j8cS=~l`> zr3F+F1f)bdq`SMjK|s2@yBi7V7Ld53JRa`<-WNaKJ!|n<({uLhnf={^z@5M?0x}_= zSF?NS{3{8n`Qdaooi9u<5(S6m`vReik=ASb(tzt`0cdCQlF#2nngHtv2)ZD=zV(P* z0u0}lSlgzJgTNa#Bh}Ul-1MtI)J8EIe17u=hM1A`-7by!V~v4u!}DQS0GIvURo?A%%J(Ft3Nf_ZE> zbStFLq;Dd<^iiIGL8~W(bktXh@<@{cLbg$H+BO(0J7J(4gE*=lf;X24RY*2!vih2(vir48Ndvs; zH^1mI`C1q^-3k?A+tqb;NVFot1lH8~(Wet+D@UB@vfF&u-7AQ`#JNX)UnMae(6JYy zenCcUde1<0bKyOY5qPNye75IXUkSL8L2S_~b4)`|Hwow~4ae)7PPvj^NWEjyIr#Pd zN#sl-vJgi#Fr~l_jc~m-`M{iz^MUl6SmP)GF)m9lvL}7CN{4qRx=3?_;{5Y3eL!;p z#to3uM)>|b5Lf45l8A>&k!t(Y|hjKrv+H9vDs4$Vkp_;v?ZS%)B1|qM| z>)CvvmM5|P0~-ZXE-Hl?3PP@gCeeOSKN&CH;1-`t7gnq*TEA?LFjZ3z6m-DW%84+8Fu6I z<+vyH=I}{68G}o^SgwNnkF7(T`vc%8A_jbuh+x0{RCtnnMtk~D<2obqb+=#=Chqk2 z&lTlV>r!k41Bgf+?BCP$0!|F5-k-NCYa4M}>WQR1>Go3bWBa%g2?J z@l(69LE>^{yU?k+v*HoSm<&pD=&;){h5$mHU+)vpv@3_)GS!%Q9Om^ntwx4G-0gfBw);Zq{(=L3+7MelnW5Dh zlBCA;Hx<$4c4y96-r&J0(Cqvt!(Vs=b9G*Pk?%WlKMW|V`}JTMvgF5Os9D&*l?o%M z(4Go*z63ZRXpM+F>j&xf{tN@y6vw3{yfTef21C*wTF%2!BXo0#R^$J=T| ze+oP%;7fhJO!8gen-`@vt5gS1WiHXJ@+sn)r5|v9LnD zA&mdJ|JeOWqmTIIpf0NBjm}vMp6B8cW#8UgscB4BPYXQo`t8*v)EZAnGy{_WcxDj87BmQ(1UmCq@~P+v&Qfj`UE9RL4h#L_qtK$| zs2cp?9m5nsKIlfSKMxlFR@2WPJ^(+h(^X4Iv=Kg(kZ&#xiW0q6vcVw0yG1eaOZHKU z*>i9+!OaXjWaqPFH6I@Bpwj$yduivFnax6l@o!b8ePvNPg`bTVwe1))*c%gtfloU) zPa!O`D)2B2vFK_R#-2$SJ}f}X+hEAHv0~Kz(B_zpr`hzz*>vw+Ie2G>1s=B|Ci4k6 z6(J_c!2tf8)7bGfUX@!Pa3gqWxaY;6Cw?(%;0j^C-n)we!UsTb3*vTs;t-xBacAyR zX*tX)VzqfI5wr^i0k@MV^g9Rk)w&SvuqE4W{CcZS%+17Q zMKIHTT>MZz4)=C9w>C*v%AG$>|3B}L{`TTr5j<$K78sWt{1*?ewtOznV8r#(U5OaC zUR{zmV}3ArCslbLaH6c>-RED<84*DYCP{tnK~&ag%N8?tquXNVZ@QL7PE=)Mdtyd8 z$;ZwP<$r=qz-tS{t55$Hc&ohGf<8^v$UyTApE_I}?^Yp}&tN6nXk5V~>oi~OVQ?)C z)L%f53Bqm+gh$P>cCkay_&rzmZ|wzX)}){QIv881%e2Q>Y_-A1eO=&QKon@(Amk~2 zAHbaAW8qcL0i0t7#WhhyW&A}ZUuGsN>Fa@bOeF#BIWpiHM-@v;5wSBnTtrHW4ZqHL{i=^_nS9N^ zX=D=p$N=Q-60zrgY}KaOa99k60bF1GQ%%pchpTC~dap{}O3tU4zfVUCx6?FVPib%| zos;WJhku%-j}F(LPc=wFc5dJ1%^>_F*g$Xv+*}Z#AqilLpduj?P`aZb`2k-ECbEzS zn%#LevGW&Jjq5R?bN2;Iys=N6%E+&*@4b{S~-_bDj?E?~BL(xq~_X@$cc%Uz@@E%Ad=a z#=T}?ru!@R1bnfaI~Mzz#VR>vERwOf)SF}Vb;B3oSLpqXWd`_!k+0J06IqP;u}yP) z>2Prl(Dt9ce*VLpX_=S^3&_bJ?qgG2VcUv9hyO<*8YR&cJqJDdO(ySUULLYI*Q&5l z5#5e_#qbFby2}o^Ho%5Em8{i*ND6iY1NrxS-dDo}<_tB8(o}bT>4!WWuSU690zTb9 zYYZVGyw(RFNSYnD?$TBt=VcdmPTILI7TGfhIJ0I@tft*~xEaEz=Lt9vWra9TR;9!1 z=BlsOxN_}##RS%!h&HCi#K#URm&X!ReKHwSYoaP{iGXh~$h?bK-@S8idAYT;JN_K| z;$)p$n|8MnP~9EURp5LreG65y-?hioo{phDHfvyjip{N_{I-)BmjDs%*r{4B-73A-^$PPNW9KR8ojT@p@8DbJzSy}?xXs>?$V+(=AB8b;;DU)z{bgz%fYmS%t2sO(+ zx;J;7GM*%^qu_Hcq6tzFcCGG@0!|FPcs$=2A~xXiWCA@e3rliLqcN6>3~f?uwNkgr+&jcIYducO}Ef-xtBXcFh8P-^B{-1RlU zftQ(xJY^{eqXEnpYorJvH2I;}Ky|{+83sXf>M6Q0UU_A-)HK_xcXnFM0VfPn`kaqn zZ#2AN+Pq@Itkjo%`6xcN*N%C@#a19lgL)M9-`GqCRHHa3J)99F#@MJ z2+6oEty#!1PObe8zbKG5cmO{N$x;G^I&8exB_hr}F<-6mVB z=)Po7>-;1A?(WP72_N&P5|*TcXgFO>e>9vq5cY=C#kxyNk8D3iMfxe&BPmkqoIXsv zH{f+|(RzT|W5Ik8vvdd8Ma+M~MgGpOqKxw+9jND^b%CbOas7LyZGPUBbphT;e_8MB zj5(#x9kv=_dCTO01F~I+GnQW!yv})(j?lf@&GyW)T>9Rex=TUVeYJXWAts|Q^fS>P zb~J!J#l^yjh`FwAfWNx~^6$TrcvM#W`02#FcVpc>a+zB7Nc1kvrOkj>0nxm`Ee+KB zSP(}~2ZSRC%oBp1`E~i{#2v0HJiHVU_g#BLr>av@3x2mab85}FYJmMn7?_I)$Jk6C zT;8Qe3|`5Tk?FrD+RXNoG;ef&D8#tt+sp52nae*<5CZ(D!h&qT6Zf}Y78l_48hdB| zC~ff8ORGRs#lWG?r3^xg9m3{4`%xzaoo11@l)yK`0qi%#I`DzZE84xcQ8#aCg<@z? z`d-=`*$BhEwp&UX+0bXGn~~r(cuN38ec2G}yb4?|BjzQ3ZfdT7H=*h)EQdtLeIsYR zWUDO9OM;TOv2n6U(nS=2sILf=)ODWj674Z&SH3eIj896 z=wrM5^X9yK5;ObpygBcjR5F2p?T+-y)5KT8n^$1I=5b#@QG zW%`7E72jirhFl>7sYD(Ja6pC*ai-oVL->#coc!%5)zK)C?I@9JK~7wPKdEvFiD-OT zFNuPmM1SqUl)o2$jase3;rBS!uS$HFxTSFUOtjvxgOy)z_*$q&OBnJN{OmewRFT8# zp-SFSf`LI!RM)q#&fHHqg<&e`FYR7QNE!aQw-EyQr_USShEP8R6T&1%Se~E}xsg13 z3Hz~eV_?j4o~gB@d&9k%ofxaK1mHr1O^_Abbe|uLPH?da!NniQ$Z>wr_qU?u=M@d; z;HP(bYx=25RUY?unZ1kQjz(BbxsA*E`%uzPn~VP}?_MOKgB|PjAfN16)*Pt2n5Q1Q z$2?%xw}L06>Um-fI680wwPS=w-P;Ksp_oPN5`E3s?O5cz?Nl!P#pd^lnwR%VlU0LE z3^X6#`T%AGNZEmS5jfRAfK3M~O7{PTX8eyO{dRn=TjJ zbW)h0@nigsFMI#VIC+mF5!1OZBsB)hPkXhq3H$TPsc)Ig$;uU9fheQj&_|>6L^BU= z&A-w&ajDB_|9~}L_smX$T4xcaW&%|T3sr{J5xOU#MP+JxwUWwC=I8)mfey2Oq5cCr z`g$3TW!89JRcg;$KAv8bhCX!{AO5NcU0IbkrZ0@Chz<+ufQJC4F6pv)M zN-6QQ%R%ZCHaZkieBMLfnTpU1aQAh)wsh&Ogg!edk^Mabr1TWRK&8V_IM%^KWa(03 zj5v$S|xifzuayn{IV-oNIV@XW=TPc3TAG|W$6c8C5g{R ziXkQ8s%@QCy4YM_-^6nt9Bhi5J+LP!((K2u{Q&?TXxOD1E&(D-jixafZTgrR-{3@e ztDQr?J`u&A8a;QKFxxce*a-lF(D3>cT!O#jqlsOywInQO--b3W4PMMgjYxJns4v&M z=2xq_TB86U1kDV(p#K{<+@V%Zj&aj*LQM-Lr&M7*&oVrzVr(0a-|iiXtnrga01$@y ze)YjsO2L}8A-h*elEa6__q0nszP(eh_){Rt5_54F4@EX6F91ZK#k6R+TS;!?b5KT( zFP~7p$#R=8oo*l5p2b$*UE5gF`7rPkw*Ua5P-}Y}T*B-n9ZSzdQEZC3ac6!z_c;*> z)yR<5xVO}GlL``QK0qU$Sqy4eT7dz@*&uq%qGS#~iZGkD_l!fzxmCSv{a>-ZT}|aX zZtY|QZ|%Udp`$t&D1Y?Pny8c(vP?d9Zz%R{x;1P79<;94 ze)U`!Tl(k21L?S1Pxc4iM+o|JhXw(F4a(0=f=ig0G_p-zyTd({i8LmPHcR&!#0QRz zB75I?HJ}uWm;R>>>`=w;2^e_uAZ@cZ-e;_vX~+9x@S}baM(R7NpTg#^y@;fZelqnC z031-4epV!ny++$f$)B|j=^v28B9`Ll~&2@ zawFDpXeOn^dhrftc&-+x`T*dDavc}pHn>pM2%ol?zspNcXQ3x-Rj)_s5KB0bIGa|c zlE^ydAqM~tdnAf8(J`LmdP&pj-FWpO0ED51`Yn`y3rKlCM1o(%j@QK)x18B0g+2~P zUfii`8Hr5Ng7lS9`)dG*K;B`=aFtkshNm;@ak_3_9-|$rgvzQOCCJW)a~vur3qSLD zir)kPQ7AEU3fdC9zMn8T))g0oo-XFjCEI==}`< zHYhalVw<@>x_MhQX5MYh`jQtx1`_Z3=G~9)D#bt3TVFn+D3}3f9aeV8zc2#srA*Bt zb0$B#@E|2`Ru9>NdrqbsA2Z{0=}nbouXx#+fDZ~Q2Q*P%0aqz7tix2GZyeQ;DmN(8{uB^s=n_Y@r;yN@|(C89x~QM^kxBuMh7h! z>yX{pDzADy0Jxyet|GWf!m1~%@9WH7WS2gFZ;&P1O01)%`_b;56jxtjX);Ui2>`gE zhTaaiN-V@9!Z*tYf7{vnqT}+(KcdIOF{)JF=waqN`S?@Ea1;PM&_JFKTqR99aq2P~ z`PrhI$h$pqM0lc$(!4~`vLh}M+j|>oognEQt01&rIslgtEvVC~&3qVJgF9yAJ6S=m z(Bf+sS5~0Rz?aJ2=%#G|03m4aup9;?oBS||e)L9EuGurI@fO>7e{++^wvB0XrKizf zK6DNQfH0KZv;a4{G-`*$J67dZ5iR*Om6az@TOMSI{iadwRTFhYboVVVy;((|O7}5% z0XgJzDmYZGQ>YRv`h1EL=Nn)-kQ%_jXDO;UZT-moTnYf9kloT64E(3q^`9WU!hIjO z4X?W+I;G0lk2%RXL^5uhhr2p9ZUm0!&8f;FXhVgMD(0cj!%DqG_eggDus|Cnt}xJqmz(^UvljOY`DDGtqZCSGYr6<3 zo)73Aqhuj%<5KSd0KN}1?r@b>KNiX3r3bx{Y0xY;ZWYTgc#08TtEScHFhAa(-|CYI z05&KwXBO^O1Ic8+*h`@|Ty&OyE50APns15)4;sLZN= zZnqIn4xM#5h~DV2v8iqhE};y%7GJnPV@8}80ss!kEzT95OKn7Bx_y$89qgUgtybS9 zP)JAK*`CH##n!Rbp+^oAcC|V?bQufNphVr{h9ZoU(8M*iZfE)Vd z_5*H%Q(r}4Z|ui2zP$W>L;ut{@7Q!fq0x?NLrt?8x^PRk*Zdh5U1sug0hn09c_PQ3dei6Z6XM ze(+W^@&0;bky>oP_b-(4hGrP8#fjxpk&l+FBLTn$4a7CWjb22GyLTETPCdR&9yQBo z%I>gr4L1X49z8`z2=z|eIz9l{p?vQh7*HnFYb70vXJxwWpgjKh@hIjy3GMtM!cBwc z`|%$b=ZFBn0Tl&ZSe5UJH!GrE?th-k^-;1(kw&BuI4U;G03zUTakE?trw0suGEny>+nLu_ZB$eR2oolP;#>^PZ_q(F11 z0iRZdDtRqCyf{ga3IIHi<5&s|+;3aoH#U3{ZueZ`&HbO=zZz0|v-Mvf~Q#cfN+EDn3xTyIgng`d4|n)R<|nEtXf5(oEL?AOtlvm%sq` zu}r5P61HB40;;_aBu4Oh-|9}_zW$)ohqSj(x`u%1z%C3qq&UIAaawz@EGr6hLuHvP zp!VuM(tY+Wkvrof8i_xT8L!s406+vPs=8=H<~Uj>PRBHEJx)WJt2Omq3i?h1^&b<_ ziS_1O12{51=Nx8h-%j#1C@ln8G|<^q5P^0Lo?CtuH&_zn9jr~&sD-`GV4F*1l$uZ#v&sH%6&EdH`6{%@X^2)rYdDA-@ zRi2WFi$ezhY*0yi2;2t7s^zwDO_{7QhbCiUJgJPAg%aLMokB-JDWZ%4SEkGXzz&5* zm%t@hb6&$$==D1s2rud%59ubaD8!4l7qieL4xZQ1=V5*a01n70{wE9&OIL@oAY!v9cvbZ>aYN zAXWlG;GFXe*U+GguaWN!BFa~=5A)<^1nQAz;TJqHi8ve66o z(m2E1Z`%^eL_^_ha93PicG&Xei>@)(;oSt81|)as2>=K}t%C_L@SkeLC>%mijs1nO z{@qA8Q(T6f#PfdQ$#wTirTE)v>K}G0EN@A?^YPTCy#-1ThDIvV;1aU(Tk$3O-`T}> z^-@&PMIHA#PaL@ohVk>Nc|<$yYqA1B1lsp%fhS)HxBd5mE)iE|?O~QD%FlJw$FRUE_ z+YE;obePZp1NhpjyGfl3g}Ia1676@C{dwG5WdoQD@Okc*@Fverfs-O9GZ?roxD8YP zl?)AqlLgvOT!%~O=#(qw5wM>N_EOHee1Dh{TSs__P+*KIo9jhD_wp_{9)o8&jawJ% zq0g|E7n?5EVsk9B&3RVG#a=@uQ5=u?OYhpscz6C)U`lhcL9-__a0vGBjtms9U5 ze8zmebKSLGX}`Oj=EMs7QW)EVYCB~ButNir7XT!_`gBw=VB@iwg`cmg+$_77Fkes`ZTo+19l@wzHn<6pX_F;DQE*_uvKepV#mx zoZOIC=Y`innpBJT@w<3qH}-bcz@L|&j4A^e;Z;p`&7Voak^Hvo4{Lr6M`LmbJa)6#)Q2sN>WDZZ!SR!sg%o+VZxhVWU-d zV(Y53g#2yu%T%2}^wSQ3YlT!4CIsIFq$^D4-J0~Bm1AqgXbv}XtzF!p$11}_o zMh>p{jHhuw)+^Aj3y)m(&My|zJQC3cD~^j3Djd5wS}I++rh>j>)~BPEI`ocQP~Lj@ zc1yRm;bo$3PcSSMe%VM`dQ^MO z62AoiHAvbCo;P6E;1Y)X5-%L(HccHsm#bN%WQODrTA!?uKW0qAK4e@Z6z+Md6&64V z01@bDwF4f9Ef-R6j}gzUtwGM|LVjx6hAaIv8+^_<6WER@8^v|%B9fjPRN>d8M)0DgW61HBY>jmj-2qQa2o(((Cm&M3=p}T1(t(b$dj6cZ{@?2 z?_yCmoC)IF^!4dvJPW?*g5xnaGh|;o3s(u}w|CR}wn*L{KE3;LfK$MBTsC!(1D;2! zS$yQiQ%lgT+$>OS)y0uU#!i}|o6Iy)d@{5UbbBwRrgIaQV%!xP2W$djlm2%DI7* zA;@ug2c8|J{K4St4Am#}MnKRc^)}0ED5Yq>C!`7OW<> zk=+t_&^_AxQ5%P@eSTc+3JFexwI{wouWaF;ZWV!+el@~Xx}CQFx|;X4V>ezq*310P zzSo{OzJ69U4Uvo*ol|o?H(P$0H65xYbgbq>*>R0&Wy+kOgpK*4Q7pz-499D zZ#TrsfSr$93_8w^hAlEI!y!sW=Jin|`=atLUKJHz7ZI%{vth4HClTJHn@v1_!FYqbC=KVp9{{We?|66|`p*>gaJCDL%CkE)g4MrWDt|Rz8Sn*ae~@n1qse6g ze8xQN(6``uxCENQGpdlIrbhpFZd~b4`^f1skzYv&4oc$9jw%>YmDK`(1IpVNfdPAl zGISA+U|TsH)Lr_jyvv3d=8rq=TdG*1y-{9_2wVdIC*(342RC}o3Mze@uP~AMlCLyQ z>ZLjvnXI7gGnt_&)&e|Yr83~4{_L}OrAD`zvWlk_u+@?Q!vO#uK8 z6q6AKm+-93DWWRE-oK?D3*Q9;uMg{0A#tNmHSbY3ab44;U0|H>2tvgti*UEf8@P6H zi%xNVP?f)%V3N=pT=z;6{o`A)m#Ik@{;~wXUg8mgA_p!S?LO_~De8m&ngV5ac{SK5 zi??PWRHD<7UoyO4$rq&j%Gu)T(CD?lK~RKE!1j+mjf%td$s@v7X8*)8O8Y;ZmutI-IuOL=qf zafws{X(&LdlBb$?eCS3+yG#MMmAbt z;6D}nPz2eb_qULAh?M3yH@kb*w1)4TbZGXOXt-?^ z_ld=Ypzj%sg(LvrhHA5y;BNh9bb40~2j>RP*)EO6k#oC1WS4Zy6m+V?s6thEoy7$J zJka9m#l2|3ehNy}f>L}JrKVZ(B^qTwoLLCUIsk;AsNWZEyKK7t+Aeju*w_H!E5)hr z&RUgEF%??K5{^F}=eD{(SOI`A^v!-6o~`+WbK&mRQnzFqo^K7|zo~apY37>jV)=4H zKjukv({Ka;BGBf^8Qf^wNTKMtFdA3B4T3JMtgr>n4}xOQK*+`6b->Pul~pt` zf;xzGiYLo|hXI3XIZcGO%0L$rS*?TY2N8-8GgK5d1GfS9Lkxp#Ye5#!Dz4XRX3M$wM|zyh^~_P~=*bCyn;hH!2-4DT6{W|hIO(aU!T85!ejhfN&2 zithr!BorZ5sMf9w=o&|i_Otbw-|7|eA;f*65`=n0RVQWrtHGMWI;XEKH*wO zt!;o`gHugCLq_%4dU_9IVz|+^F?h2OTuljaKpi<3$75Q)?AfS{B}(=F+pM}C4~|m% zM^vQ4qHy2vt|HSo3=#r>6I!gUgvVh;tyYBtlY9;({1!#kqhIvh%EyUwSbkwm_<_RR zDxS>%;DRcamf=QsxXW4jUZeP7q$ksA`YHbN%I3(Sx_O$fZauLGFX@28({|Qj6gig zcUJ{zET3!zqCX+$iM@G7!oGYwJgPSZ05)hXbPS$LnT!F~r|&uLB0bKmn0#c#9g$`6 zOVw zUg1VqO8W8S+2AWG4Bjubtiio>qi{s9^ihzG>`y;iTK6~WHkBfYo=nm-4vQ~eB$ufs z13(Z;%eZj%w={l_XEedG*^#4`-;7U;-r{Mcp!|C04n^kCi?}^{3IGT}eyfpimHt!M z14URE3XgGz=aSXIwQtv7(CML#ur)FE(S1K0(rzK?(Mb3jnD~<-%u5cGAOdv*~1!0D$`kw+kQ^U*?J}xdF6rm81H~ z&O)di*2iu~-;w4x5}lcWQVMXM76$8~#Rsm^DUw3@vb^#_WWR&ynY-&6Wk1`2G2a78 zx%%l@Jk7dy;QcH!bg;7zH#+#u@YGP%J(^O+x#0XctmJXMlbaS2c;o|RVFu!|@00<+ z0+mf1!{fm3Qdj7B#yxuZXRsoDfl|%s3^AefWaKx(nwN57b`HQu6k&yu)-R5hZ(Tjp zM7u=B%+zf=E8Ng=>=xh2;HYxgxtD!;P!aP{5&&$_oWsQho+ryke@`u}#P4x{w9ReFBE zlI~J=_80&-pzU4|5sH|t7=tnow(mFGe06BY;6##pEMD0=FYW(cZ4QG{)zNkfObroE zsA}Qj`(T)WHqozhS=;bNw^F?Nb17L1*q4pRCY>_ZpT< z-dS-cd_2BuA?b{=*h#dvCu8YwbyAzMwZJz{gd1{Nx-j9WT{50cJ8Rgo33x%I6)G7?rpLxY`UDNAvd`BuO5N3bE9HUNa6OuGxG zS~+D^ki}YszRF!fg>4O>>W1Q5f55Cu7gN$00)n^M*}Xl`~OTygCZgdJXjaq%G$NFmX+W6 z^@_*N+2y*1?Gr^2cVbD5kfROi*L!)PCyD@IgR+14!)+)S8)D>1P*NtW zv8_$Uw?=hmD|#L65{jUp1H-qFm78VKBVS zAgS=m`P5Vtzr^4TeK9}FP;$UjTgDZEqRpImT?)5s4glQHiSxx0rA~_!CKfyLRO7sF z>+gyFRI5Gpagq>ECi$DJ(lXX&a7766Te_|sS9V$!r@+z{3j|jv*bJPUkP-P`GmSY zN$xMZ+b8snTlEU69RP%(jPeb*(O0%}FFOQWdv{Zh|1mFQ>K{WEUQ14oN&V!MKA|j)rKo*ZC1CLP;L0KZM4`-pQFx>S zA9KVrXdF*N8E@OE?P;6@%CAObsaYaD)19dJ5pTo{05Pa8I14U8D}eln1GV@0OdYbJ zUwYt#prX<*cC9TTEYGO}uKlN;f75wQj$K&yM@0`nmXM+1E;amj(N5-ea_T(?jLInM z6qonPoA_+NmAM!T)HZZ+22!(T=~$&R$gvC!7t0)}L9IL05_v1Y*yqQfCnfqpOCA8M z(6{u9w?7Y3+vr+b8Bh{x9(37%k`Tj_nk#&yVVcy$nI`yaI+PXwY>?mHg>Q!US>vIu z4NdJSS@B~|+u5gFsAtcejD-3;-^R68cT@o*QH&j$&x?Y`fnxqs4nv~h&-^&GYYfAQ zCT|VpniVbYxr`M@TX>=qhXQ~Dikz5+0izQ26mJnD0-7*Z#dyyw#WRgp_mGv3EZ>Ff z-Y8p<1}_H1IHA?_I=EY3f4<-5vUJnrS%p5`jghr8s=5eTlGnldVwev0RH~!70N{dV z8ZXX3Oa)1|xV~E;e{miEG38d=GdfhD!ck@>e4tD+v{3T^-Z?=`j(;6{hNM*~>Vfh~$MLBA}&u^H9a=Fz3AOh_cwZi}|V~EJ+Gp^zE>;KN$6W8KalQ4Icl<+HOWUl?J z1aH~1nS5h3LjZ_D=^t_9xP_i2waCJd&ehvxY!rQZP^LZH|DPoMF} zFe0A|BH;S30`C74kNvmq=VE(JQ-sttkIT8mMEZY<2$AJP+(0jAqQYc1nhd=(alC2w zFO)^)x}eqLq=mrnVSz>xIlWq`FIej;Jhe%4`)Y(7k9ti(5F$`!`xjih2?tYIAb;lM zr;sAhq>18BnLSmJsL$DG`XN#nZDunjJG?Xmg3E+BSrEaJGdTqRpV;32=I1!ic5(Vw za^^o@Ln0(ukXa*mxXKfI();32Q$Hn^J;J}sa9L(AM#|tF7oo}XjK5-ZAZ^9pu%G6> z^Qwbzp?03`0UphX;~Vu$THa_y%=$74K401_NsY&X+}vKSO#GFA`4_*u3gQ|O<)PY4 zlAKceY6`~P6nH4i;1iZ8dOF3m6Oj8^Ow>ED7U+kw2!Vje^Z3`HcsS~ZG8OImcv=pj zsha=|`Suy^wh42`=d?$J4^8aj-X*gXg0LnKjfxO*EI?$l0@EWy*;!n)7xRm;CUn9` zV>UD;M)`%bEd1*IIjp0g#vKrE%f<}UTF=XCiGcMe5}nGNjcf*=j_4^fX!JZfyQy|t zkYXE^Gjv7&H%gi|xZDMgL(8Yh|Ak$arRki8qx7lQ4NI3@qvXaNuTVw4^&s6>fv45! zvk|i$NI48rd!C2;RHhJ$#{a#`;em1jUUbu(iA@1n!2p~{PpUvHM>@fCn}EZYrqMDq!;I_ zWjzv}aYE?UYpmr$oQWcvi*G+L=GHt8W_zcNLGJTQHOb^klO*6oxqu$U-{Ic4(8G+E zyQ9~b#e%*PkCw>aqC{|uJpGCd@>KW-c1zXUZAxI+IDlpeLQS>-5%ve_iJxMEVUcJx z&{R)>M7;X)!#%Rs+tlJ-wb6HeDkKaDfG|T&AY*}$n#!((!Xn+k3c5EoW^4Ca}ua0h~;KSWN8|>Nb(gO?8cc1c~YC3=WW$hx&FrA_B+sO5^SP2?d`sji*ZkYg+Z>Azgfwm|2^E5s1!3qWv zuORQmU#?&RZePsrBXVq%m$z?><-a77_xTj`>|}btQR#_{$Rv-Y`wUQJ1hQ~!2<4@E zge(H6r-qPZCsBhpU9Lya3k8`shX;|O3ZaFTj?K60pyPU3ud}kkhrD^@n zwKDpuUYpYk#!-W0)6-Q`-{$>F5SA?j>WPpcaYtxzg7&F?4nUuoNkFM!pPB0$<}6Pc zTRN^vRo44X8Xhkebp`aN5J-}XkeTSc(Ee=g%4h@<4=^h>MA$1 z_IGX)J)%DVCjyd2pVu>b`g|NfzbvX%wbIfEm@nKV8)9LY;ctpEr0V6=e`c*2DUuSo z0@NynfjAB#96z%W?w7F3RGO*Ur0O&wuRQl{cz+FTW_Nl`S_h&qz=BF!(d5M)OwEA=y3yh zEb;AD1jr>KXEB;bG+A1Wf9YD55dD#ZVFy_w&$qwhJ$RpJb?-T8Us$Qr6(&#p{nAdZ zHHo>Ff=w=#uG5a5P(txO;DkW)&gXSTE?nM^S3=2H3#hI3r}s&I9~?{ypC-9!WEM{_ zlsE4-l*@_#3D@NWStI|>m+%~T91KHu2Ayqm7EwrO3gzWcs>+GWSGCVbInCOY?8p)w zArL+bGN2;%&&Yi^T)M9$2mkCxyk+cO<*=p|AFty`U;u~eiYi0#8UspnItk!7fdbxn zc^<#v@vEBsWn+Fob47{p?o;euk-?O$)8^f5?N|2`Q{&Y&t^plFAm74`kbT+i!b8Zn zNVpPU+99E`BiR8B8f;)VpfwX9iJ&84Arasr*`0rXbN@!cHnF_Q$ccGYtbNm zp5)%3D-goq5d+Eup*JtsK!6SiVuMVI zz{kD;qF@Ox>;**p>tAE%JW)iG4A-#y_WS;d$dUn;r58nSt|te2PLbYofUa}LJtMyQ zug1bz{b#|}I>tEF$>Tg*-&AgKVOP?kb)`rg)<_4wTbu=30?0v!5UK0)hPOOBffl|@ zkF1oUI<|PcxhC5rf`j`Kf;+TWVH zw+Pq91SH^>iGgOVWYc4G;zC+X;Wu z-vwX#6fQI%hhe2-lM%wPzD8*mZ}zQgOxwR=L3~UDBzR>3nOx4l3AjoOw*>E<{7Oa*QhL_l=J0Kq@aNl55q1w-s`Z8aqeNB9I= zj4X1NEW)Q+W_x>cY()2?EDs*&T~jF-RunwGCJ&XTkn2fCQtBj!(fkG zc^(X8`hmJH8zQkvz(qn9UP@K+%cK-TuC$$>zIR#AJ$Tq8JC`j*sTcKDlstOn7;t|! z+VdUSdma|Th(zt1oxtx*XQ|TK2>RYV+~cQ>KTqN{SN~f8mv8zW77-2yClJCw$j(J0 z1lYl>F!{C04n4RnUv7u`<|YT%uS56Y+tj(H>LQocG>~9G@mPk z$PJiSGQGv>5k6C>tIncf3~;KJ zj35iyrjJ@^*k!sIDgDch9JQi>n)Q{aKnaLbh@Bmw)Ej+~zaZmIS^nD7-J5%kBQlE_ zsv+E+KfYZ0GNRgOWh}#a_&MNFZ7i-v?&gSgc-7;>D?L;Hr+wT$a;5Ig zkAJm90HqHuF`$)m{t1dbI^SwR`$BImD)8~Vz2-E0dvwEF(!^Esj>kUTLbJup4C8*$ zM-{N+fCM*)dY1RW%Yiw?!<(!mFFE1goBmTDj1^~?bdh*~0+ z(a#y&e~K2r{4c2`NdG34RT}tzRw$|&R=^-IHrrD$FEF1ipw~I^ zpn0+PIKWAROU*s{0|x=gRxv9urGO=jIB@Q!!k@HCYF(<@~DrE%+nb58teE7G{f;H3G1kC zux=1s!&g`b z>$l1{(R#|5$LSu!rMAli29g_v*ztZ{mxq#)Rz=qGKzTr4wzA18Bk~-d&+Yd6KhOWUey;CT-?}>2eeU;t-sil|uBD7fOl<+} zF2fD;95A=$(>B%K9A`boJ`)D(IyRpBT+iyalWyD>ohLmZdaThrcFj%f8hsrNDR}*` zAQG#G8mH0EP*6ZnROLF^+DkE-ZeO7G^xeg7#y-A>9Kkte9(LD`uL9EGhr!C&2kyM1 z-WzMEN=ImwdPCB;KQ4iSmPVjIkSFd$MdC)<@v{~JRqNEHFz61}Fk>CAIv+|BR#3@bgFo2dzd&`_to01#fw%J-zwfu}*ogStP~wo7=#x zfZ3hMdHtwCflHaa!|=Or@}hqqJhC->&quCaalqmEve-Srm|u5Ia1J`}hC5(P57yBf zAEd;tuidwxxc|e5!XGep^c~f%9sRF;b%<;Ux|+M+!hKqx&2qZBaH&!4&1hND<>V?J z76uEJr>f2{uat|MAI3akzO}a-sv%{EqWX17n?7ztE>)4lq;!XF_-y<3t!0!7GPkE{ zc{u_dtN=r18b%@-1Z2xiCh&FM_QX2fvz&QXgAgTGD*IP)M`Ji{j(1dC;Msr~eOxe) z6>+kD!!Twf)?ilD6oZ$SoMyz(c4+aY3MH?hY~`o8=B@CBF4g>h*lH6SlgW)r` z4L##J5eLIkiBOt^2?8n=7K;ZDG)kWu9?WTi;C-=)65&^%lY_OfNK7Of)vQNPyqFU8 zc_2W@?znn!^vk?Vn%rbWD zy*Ad(d4zK=lh?q;GwTQVg1r2@vVeI#|1eaMTS`X!bIW@ngZth(=VfG3ZogMy*)0CE zn|+bK73sv?Fp>&j7!1wF&^3QV=avQz&}1ilPP(1l+rq)h>=?O-T(!L;qIOhscShLQDH@#erGxtR{b~2{i;EbMEdh-*evZ07iIc@TkaU5Xy!9hks z9KK0K|J@2MkRO@hs?`QJ!93k*!iIjdN86J=qrkpLe=n6QrvpGDaurE~l3ex@ZS(bCTFxYu>Q zSKn%;HuaVSVp=YcyO;J=0i7^96}NsL4~Yf^>k0i%B(-#Mp55c8R}`bx0;o%)hDy%wEux6#! zYg%`xTu3*R(sr@RHZU;#Z2MR%C`8y+%7wi=zTeUJ64}%Z;VKgrp^b`@7>jsue7K^p zaG>9qkvc!Ef2gin3Fu&KBO;a?OQ^^BM*Os(cBS9YEb)clv& zG|<6XK?FWkEu)5&mi9IMPu@49UzVRvRn<}7^hhFpAbZ}$D(c5AQT6E{Zh#HE0zwG> zEoejokta)^u8AL5e&f42IE^zJnqv8-i`M%7^5>`Lq$mDZBnCpI8$X?Y6ZRZ|KQ=0w z$~?t}(Xi^vn| z5}d0LQdV{`vh#5;vV{im;gBamcOilz3HyVPeG0zCsC>}za@WSS_P+`))pWC{>~8t3 zT`%=+qC;oPD(NozM==Xpm3jK2Jp=%f)IqMsu~ zQCrJLujIH4ax4Y=gOI(bmG0{UYw~6{C%1f-?U;#aMDSXXm>AGW!yHP)sCuCCcqi7N;wLk+yes=*UQO!+11VE> zx=Nc3Cp`Q%+cZW8fU$Bipv|%8|2qsBJjR4Wbr_--IOI4oOgO~24OHADR5-YJPIxI2 zfC*erVNd}U(KPT89lv{~*hA$!$tvlwUfK| z)%-G~1P9JG=@VMf9}{D|e0c_}H1NOYh-O72h-PoU(0{@iWX2bU_k2tgra?MSur{M} z+x|oMQyKY>bmOdjZelWbLI#7*I7VBKF7EMu%**9S=-0!mQd5e;r>A}_&*^T-e{Qv4 zzH_hbk=PfDcHkW#4Pv8WdQs(niXBe~NBxY3EpB_H3!n4I=^CP*a_#GV?|<45iQhaU z2bWrse{Xu|iZ3+@J)p_M`)CZfM*tayY3u;ChAV>SGV#W0?D9-xVxDYhUwbb9mw3V6 zYPjc-5C3DCOM6WJe)i0P&ddv))TM_+4*4EZ;3jyntaUE%bcqK2Ueu!OzIKBlnf%L4 zjpxPjW;p7lV-p8HC5JS!YA%HZ(7b<2LkyS>t9|=M(c2|RfBflHYhe-zLcGqobL?!o zl&qsPoi9~p9Y|#dL(^b1za%V@K(^?)#8Q$l!hs*foH5h?%{_+cB&?hSTwF5rFQ?O1 zra#9^9V;b#@O?AMBCFcvO6skSv=*DaOWJOt@1&(1eY{Ma_x;GK=gn&k`VkL0#@!3= z1#kW+ewGSH4kC_ZleVi-Wfv+#1 z@WR#R!y?KpSdvNwY!hKcgBZgncB*wFzeCF3MEf~0vxalla_zX>6lR;%MMn7AqXy!> z%eVda__QK&&TlyX{(6kYNGr`?UDi7@jspd(mt$w2Ofr^vFm3M+0fcG4SV$S{ghIo= z>~3G3S{>Y&`J1LROh3HO@e&B6=N`+cBRFs`#zhj+5^^$-EyMEpV**ts|M$`E{rNwJ z1D0ZTfc@9G00<PmQJEas4D(c{BC|Y)mi4r{ z)Rd`r(%kU7J{Nr;+oI=cI%L;T@ZpwY65n>f8ktozAJD<>TSRwl{vqAV`bi%JMMdpB zJj8ujN?IXVZiXf19PTNxubQTc5<}-Nzk|gT0(;qm_FSwF3aT=$@xHa)*q?+z-JS$> zEnV41jD$x8?N{!sxzI3H)tp=gGT4}l75*5+$A-5vJ*+{$@MT^?>Yt86{yzgv)r|)2 z-}I&PMN==%F<*tQH(1F9JLIttt`w37$Vk{%*H^FIozLcUfA;3~Wt}S9nWH>TH%|GU zns{t=`{}q*G(1jbZ-nz=7OE%YnsV*bIe1%QEb~4LecQQb*tjGyqbUCA;ni;kgLG|v-ems!A>Yb@7gqx&|~hD~Bt@H3=Nh3H0m zu@)LmWBzf>y&mmN-{HhfZi{!EO{`+Qarb5qoB3K}OcPY(DrSyQ4ud?B&7abHsa<68R|Vq&fJR ztmTU9>-l>zlQ`+!@toZ09mi921)a~l1;1i0-D*C&Md@(ADfurnYk@Ywd7wH&1U@bk>v6%S_`gexTX#NL_|zepPKU ztr_TKVWKtmd0vpYM&7Uc(gr`iLmi$-;6*lB)!>Es%c2qYYA;7K#ZU}BzY!G#@k=fM z`bc~)68+r0&1a`Qa7eyfsyY3=Y&^K|EJJRtQu8mZw{Pn`KVJ-A+l`lkV~D*w=_6L3v7Fa7ZAAfUGL;%t60jPMkvh$M$;>hIVWh`cCbT#r$GP z9N;*XO%RcBEsDqa70~fO(Jc3QcAe+ejqV+u)m!6riqVtRzj#VL z+(iZAi-ArM0yWrMxA_C5OFRGPA7iz#)FXyFhO>J9*1ks;$KO2YINF0FC@DkI33v$N ztgw0mBcIOT_aa$}=glY1N@iB+Ft>+Dk2vui$~d%ghBDXo<=h$D3+31Bp%Dujbwk|H zxTi<^=%7I;Rcb4_C1notEX_>)bYfG)oT`G+>}hhHArtub{B&PFqH)hBTnUB)dGZw6 zp{&YfDasdw9?^dxFL)l*sfIg6=$b+R4vY-UUB$}P&Oh|t{QI@iG}ud&&S|H(d39^{ zw~Jx${YUX?uM5KNOK1_7O90l{4d7$%TgY4V92S!3OhyLpl-U(M3$1?e(0;t@cRBU= zQ#Q7uMeX!ku#q0}MSL*&7jq6X`xB`z&L+^wlB;D8CGFf^@|GYC8MbaF2>C5$7x*%u zWPbc1&`H6`W92w@f1A^Zrp8G)Q4-g8!`pM30n&3nidXOV$YUXNlq>+!O}ZsZe2 zo@4oREl1@eH*hj;C)MP}V&1v4Qxc=xi-FEZT$!G`i1e2W42C}i2UJRqPXIZWgglh4 z=+p~irQh_CkGdE2D{qgQwHp0q>brPM_|-FY#bZSGA>|1xzxMcSM&t^#c}EMC7I71f z6DPy3?zF@StA-M5PKWuL$Nm3ozEjbeOaPrAARsKC?YU?Gz>ck^?Vp#kN~ihg8$M0v z#@c=gdvf1#uA>Ng>2fo8MoQnBG_sw5^xIM;WBmcuIrYAXBSpYIex4#W~pH?dUZc zh%(6lpU7Uu{QdL`|H9DCiecez4zm7wo~OU-i+&3{heLUl|1rahrt7Tn0vMDjfGi6O zLi|EFmafl+CNvdVe^;-+@2iM6j{0owJvf?WL@Tco!|>C^h!`LUEUZMX_t&o|G8A?B zHlyT6r!f~Xo#uJ1l5yyWz`~T~s@p)@>RN(ueFo4;!!9dC%;J!Y?(Qm)!%R3aPE0V$ zn2G6>liOV!DqMYhf2vcJfX(SJ*sB7A5gX&ZRDP%_QKUqk{wg}r;`Z*$M7Cb)F%Qv? zdI3FpC*=09*KG|s;!Jz(_s71uys=ebr59i&H#}do_Wk+&hC3SS(;*mG&V}5Q^8JO# z)>}7qFFq3f$nur=*WC>jh5Y!_X&hQ=v^%Gc%yyOYLV`>V(mBYa@t6iQGQEej{?j6QJV(#k{q#+RpcHQfe_aFf!{$>t}rzo0&gb6S%Eiufz{$GAD=l&5>$@X8{QIOSpXPuuD z9ks3gc|xG_@N8vd#Rax*EoC`3^}md`2C>SQlWB+{i-6S@v(u>9e0LP9Iw5d|J~=-< z%v$c6)P@EFyXVffJv*nDXj)M}+(KBv4y*n!Z@XTH(s4+Ke7GQg;9U4auCF{);d*wH zXW3*Fz2dn3z0YZ=Cn*E#3{Di{z;y5L;aJ2yaYbls(5pO$z3k!b50nDW;vHnlZ$FJ0 z7x{7CeA^A^qyR=>k!@EX3U(%Vk}brzZA2qu6`9uLHUFNBd|Kmnj>Fh3C)PfJ{5u^) zHDN^+)|fPJp~kr_QSXBDl;7sxK-yvQW`dS$U2S;ghYp1bRf;Sq_{P|PQ5WD5LX21E z5^9{U^P4-L=~d9b!Q$0vbReHv`waA2GID;m`+17{HjN>qfncfn-aep}TvQ0CH2KL= z?kM9qtkZnsZj^eRX?%LqM;IrH;4$4c)yF5GM0b}5Bg?I3LQv!Klaf!Ifx>&WTeFGm ztJyV4Yq4>McPpJ29Ql=YHk<6NcfkiYEd9cKhAPCkfVN=A`{biuBjB9>@EM7z=5Hf` zlcS$$Y8CJuIrVQH3(>I$5Wx$(bg{-cV*w3Hf6bj4`}h0G9qt*^v_vw)uAR3ceBSJV z$?q+=4?C1Sp#nPCYJyAHQ|JF#KL7KrP>A5ET!$6jXEq$9E<6VeyWP`G>L1;bJEMFb zz_cVc59C-dauNqg0R(I+s3wQf%CfWRSSXhLUOg}_zVj*t_XI2-e3Y7XZQ!sG(7~!q z#93HEHXXuwmd(9A#Ax_;v5IV)%EvdU%+;c7X0zj=Y2o-uPARqYTA+iiB#5h)=#4&4 ztB>bJ*M|MN!sPq_o5CsUdZ*Y`WxAVUf5vl}NCsOWFeE7>0DHzTd~P(N(M^VX_>GnG zl4Ms{qioK-D>J*SP>;z@nssLU3 zjFF_FF+D`hrC~iVvWK;}6IGY^BNyLq61;Vwx^qBm<>ZZdg_BoCC#kRdpA5hDVbISS z)Sk2?+&Ap~uKt1QA<7IcuVi9BcGWvP~%eI)6oP!!O?HfaQX zbbFxpRFLks8;*@=bDu(fV%Xs?#t|_IR20u>C8x#0?~smHSpsSSD2J>O`V8xO5hE6u zQpEDAnreIP7-6^CcZbU_ZbeG3blrZz8BK~~0{wYFCnL;_=u7u~efjmql;M_j(en@k za}m!MZsj<3J+{_%vf^=W2K?(3^}EJfn1>h9&k?~WpC<~f4!FMgs}QH zX^X%8Syh&W-x}uqJHdH^wGn%DpmR{Y&IU%4NeV0`lLQ$)D=||w4wX9|KF%w5>RMPB zvHJsCBrw)917r1@ENT}@A0%`5TipEoiWYZdZX~sRdQ!w^U8etDxG#gi-UUhg#Fk#1 zQ^D*%b&jSvszC72o`b zz)Po>J9C~9sd*=NZd1P)ONr$K#RhAT5SX{}k&5IfyZ|{B4jzVA%r6*j%dy-x?G!6c zc5WYY7RQbI>T0=sI-TjWhLD#6d%WPZF;3jxXDWW#^qrii^>Nm(Z<7_lb%uxUJP$Wq zZ|6~yo)tFO=>*>x$~}3JwZ1#^sQ8v$dX?43VI^~)jJf2xsH%o?oso#GX>)&)YfyG9 zye@!JS&%}k82YVHlAHr>86+@lGGTuGe}BQS{{zGRm*EBee!ar;xmUW|2pB!@*gmke z@1FRnJUgFsN7zm1`X2i{_k~V$%o?(0zTwk#6Rr)LV&ISEWw~{!RF|Pj;B?zAM3jR? zl~`AM7PdPh5a(c^asOIbiEJ%@&hn|e0>X>yMPp%}A;<6j+bHDVnz%tj3~_Soo&6eu zzVyj<kVnfoal1L@YxICdQo#)4Jc9Jfh>}nomqq!9D^KD2(0P?Y!PfNkRuNO^FHJ z?R_ODY?(kXrcB_!4k<=-?(^JxF66R-FQ2UD9aR6pk~ulWv6YoDedL(CejA=`E!1Lj zL4g?(P^kEW-a)l_A}2cno)hI=^(=O`k7`Zuf6m>ty_TL(pA5mO}mFK&qGCWx6^>jh8qs+HO$z@;MYn?^!Eq1H|NM27Hy!Op!reJ7} zUaB}Oa1U0VLzV&?_y}x8F_QVR%=8xNT;n3Iu8eHEh8AzlpkClGGqb&<7|FKzhjNe` zN!T2QwJkrJ(C;^@|2-v~(Vp>vS&?GFx%6aBg{hH^)wUn~N4IdkZG}LMvkDo;93V!qYRCBTM>T-TN1azQCkeb{@uw_VilO|DG z<;qE(B$MdOsO0nUlIn{%_}|SwJ?hnL^AL&6q=gmhvU^*fd$LeANpnl((|AJyN!Z*^ zQZ(sb^JVs8)F}Z8a-MFlj~VK*doRU>BR>ewGFNg zQL#UGxtk+Gp?mFqVFCM9c9&!>`Lxl?#ee057cJHnR~1z0n&;lRtt99s({cfwoG=$6 zmOqdvF+4B0=tXLp{;Yhw%b5IRm_s{P@4LHY%Hn!LJlB_6UWCF{U`cL%*c^s|9ufW6 z^8mUh!z~*%qgF}r_?0KUy)xsAjNMF!)V0YCuvjsW4Jn~p!Rr~KAdN5YgYQ3ag6_#mpe zl0|Um$*EkvrESd!Eu#p@C!fqfcLUNyJgzd>fQNi$QbFNMV;7iJYgvCa>Dhi2x%%(V z&EuV(R&tcZmQL-E%R49~wb!BXqYAy<*R$mM25hs{7x6~CV`aMT@h|&!M+kDCofxli zCvO(M0*`|-P-H=4U;%m@Z9X@2^L*+nvX(wBhHjjc`r7$O?_@#$>u|E?nKrN+8juGU zIBM8iv$ciN(c?L=hsGRczTt+O^z$wIY1MD*p<8zMW*9xkhPd&=I)P4r2R7hgj^CvQ z6~|NAQDkQsyGqXB@PvxXsBi6PmLA2|lDc&Ax@b_2d^tPN333bZVd)a~I}wg*vHr59 zydnEd^WJey7oQBSxzpO_krv||d0C@b=QVbb6)dvj#UjnPAoR9PK5(-UP1ii=sd!+B zSRnIXF&@tqA=Orv7c~bbOoYzg20A$b$d+LEEGtI&Y_l_7U!D9dGe=;|PQxQ1%3yw` zg}Q;rLZFj2+UXu3DH0hzK3)WoHI|}Q=;cTZL#f^A_Ic59wlhW_7D&7exK!xG>D_+* zx>K%X4O&)45>isw_{?6N28iV<-4w&!t2)y;Y1&>(n;&%AuQS^}`6#1G@jj9M>XzfK z$>!(ZE2=7la3Z2D%^wyNhAgF>vwi+&!i-$PlGN)TO^gF4nNrRZnX`73$7x9Ac)4MJ z9@fZ)OrS4#F`%n6OVMNI2B+h#R{oEh>KrDEWf>(rz3K+9&iwoi2P(JQX@+GqDj!wr z;WidFXHK`jXctIPaBQ;h2v_Q?vJ~cixw)!H#ADn7)opUH9~GhdifkMMGji~u?JfC2>nLWzXO5}hzRW&IZ)x5C$K(Of34y`Gy0CLGsCu^j)5sThg^`5YFr_lT z?8T9|i32}|Us#a;tTH^Q6t|TEbke+F4lo~ZEE&D8rj}}%Z5ro=^%JPhdeaB#=sY_5 z!6m%$=Muf~JjYpXdQ7Y54<|+})btm^VZx`XtfG^|IpvB|NrR7r?*jXFad4=2kr3?T zJ;mjOhXrq6E?7jEUkWYj#kq&as$iTDqq49NdaNrvnt$R~joYJ;J*ep-z4^%bTRiiL zUw7Xvmo1P!>EQ1!o6k!=(LwcA%63CCqnECw9{E%`iYL?Gi zPCCef{b!%t#nXR^$n@17eTPabSs?)~q{nA9j|vOk{@ z!qtb{mo_Huf5{RFwg2-(2hT%h-s98V@Vgj21m8=m_2i|1`+>x9hc=F}4o%tHlRXX< zI#j%@ZBcskNnFec$fkj!#B!gXgnF(nHMe^Wn+yLifv&b@PJEXqPc*}Abf~HGi88#liS`Ucm(q6` z>dl-fa}nm92-t6I-ERJ8DeSw><(eha9E85^)%SgbwwEzjfV zrxP_8AW>w!lwe)93#<=WX$H9fL%kVrX71-O+Ih2pq`7Sl+Pmo=&?3i=BWkRcKn__hR z!^I~Rah-Rb+rNHFAcF%5Yj9ezz%2P2s_31bSE!$2Zz#OYa&k#^dd$gxMf*8{K}uQ9 z={f!$C3Y3Kz+8e5q{e)<`G4r^3HNa0j07m~Fov~R3hFp(g^W#+b$*DiaKHRgeuaJo zEH%WZ_f~v5J7EzMd^T&!)QYo0TuT1Ota8Lw8*%8~s4<>+L~kUha&w$8VJr;jWFQuR zJx&iKp$l|{TX~E%w4VhHC1=>ZLnJppTdFO-@Nc}fMg72W+~m_2po5jQNSSu_BzkY3 zr{781wlO2Me~G(t^dQkLEz)< zo`?S~bKf!z=vL%ZBqNbOcl1#2^W2z@T|Kdz@xdar8f2v?@cFA_jR92 zPrfXqR8W6E^K$G-sgrsUo-H5|NVDuU&iqJ2V^~fna^nUYhr_0OkGcNgyt|nGC0Q)( zqzx^_d+uA$DPRH%^!h?V68jyBpn?`j=za`2`N!vD-q6CO*odim{em@%oSq#*&SKNK zTOXr2X<@h_Ov{~UVch%o*H#@K<~PCiJp#?Gi@!`7N7x2%Me9z!3vIjpu+>8t+SFkD zs8hqqJq7aV^|lPF^0J%bnf`B%zrAJk{4K|k5uxiWw`x+S2e&dKW@n-(vVl%kKoIE#_ucQ+d@Wz?e)G!Z zQz}`5LRvZjPVy7!3@-lVmL946%ZzvWvvwU5XavHVhQ$4q;KiNgEy^9$p+a3l*$GiN za>s8JDFqd&M=9xxynKE6wIb+eSOAMS7~}gf*bOPUK-wz%9|YMOS*5?i{RtdnE^afH zr~K%xe-v5$5)`YXAXJKC)rf~T+Ue01z+<~AqB!iW5UgRFz&-VGBK*4}HOmXR5ADZE zi_IEo4oX7LI`(t*?H8t==cnR3*rz^~d}!iGpT1@FU5|c4hRO~6xDg*6eiie-;4pCW zLx&^gx|If_di*eN1U{a6Htsdsxt)_E`W9Z6R4JFDlkduYCcAv*($)gdf&YrMx~CwG zEFg}VcC&-GqZjL~KN^?b+~Ou8&g0-(q2j3B3}Y+}&>P|2bx?$$Km_x=@@A|*1ax=m zikim@E~vt+i>$(1hr*&dyMCOYGb0$Rbt$bjy+Hx~kPJ6++Xla&x5h+&xorDEPJx`< z`eQC9H`#)G4c78e?xEPEL0esib>Ch81l$uuio4L)`)h;~Np>T)=?uPqVxQ}XkdjCA z-B{pdu-Bb%73zPq(8fhCpr?&G;+^jy6|1o9~3&W8NRPz3! z;jC|zU0PR6<=#2{UFVRa9`p4}BJFB}N$Wr-DIkF4k0%%I(x2FWEjOUMjbu@pw!3HRbVUY_o+9Xs6u-4)&Ie4xn0qW9N{z z)`O+<4k9%vZj{RX?sZhu(FIP4n|{l$imq@$o?ciAs;{s?rSNu2YzZqk01_Ck|Kk@7 z(;qOHsrj6T+4_5hlUbkjNp)^c;;Fmllsl(tR<_OcH(g?-yt&7;I6Ho$Ma!|dl3K=S z%ehHw)uTaVjxPkO8*enlM{~&tK`2ZHAPH854>hAgMgCN6m_7sl`l#XChD-7Urr}eh zC0f^5r=wX}#(xC9gj}->+!^E}4;N99oB_;q@_%NUnf`-yQ`zA6exM~N>ZxA?>oU+2gu37m>WK%AS_@Eg%3iix~!=&aU++gb9R#W1Rp9p=-UJ6TkDnJMaXkH~;_nPcsjVygoTJyebjqmFY$pR! zJ=}8O&tmC@AZ3Yw%rmUEN0XkU#NZQuIBXYFbVY!I@-v6h{cY{W)~CKsUc1GO5Shoy zq0a}@y1M${k^Lg0nkUM>_(Iu%`mF{3Z&ma99tDrX8^uf_kVzr|oy&_9H}?9VrzzI5 z(w$n&3MAPdp;yX_rV*bn;E_E)JOL~@SO`4y()pVZ#xp| zQu|fM+Sv&nLWbd>oi{oR>Iku|hdT&s(% zFjxkfO|f6yWfMKlPwrl>l76T9*Sm0+HA@Lfp!QN-H(m<2*l3A1QFRKUYK`w?*N^QkPxDFXZL&U+U5z~ zer8I|zgmi}} zjcW-se*`k;Hpvb!oO1>`X?{M$No-HX(gEiG-f-sq2m6T`&w?%*gE!r{fo9|hj2z}< z%Uzmz56PogzzyHs(~dPqDT8R#q^8)|yXi#>?$Zt>!9$moB;t?E3FpvMB&J^Qn=x`e zxrnLCt82q1;=wv=|Cv_&v;JV#AhA_DhdynsOys5FK{iIG6OIm)clCckf?J43fCmZ7 z)wH1Rb)mnF>B#(qV6ylO(-R!NTaOobMSr^RX5dSacFcH)ckHTh04-QC+1jsqn`pQz z?MZRZx39g(q~#->D!L>JygEaZKy5s`b5HFbC-ftT-1y;vW&quezt{C!G&IpP}y1Ob&9EN>1C}jb^urW@WnBYYw|?Jl9ulh;nQMXW-^^Yw_sdy{sE?h1YWy~ z{R`~Ru9JMb^Bu69BsXMAF?1RG;=CzmUTd06-0|uoxAUXJ>{W;R$SynmDl>S=wsB#B z@H}M9q##R*7>chQs5m!p2mdfF?fg+F=(!d^o$R7Kqcd+2^u>i%e*-^7c|H?R3)J@@ zTE!c3Ldfem5GAbpjdQFv`-d8eB(gMw%zlx`o{-Rvyx$io82IoF%|U69X6)_Bt;Jq) z`0C_sZmU$=v!&{FI!&(+t&Pf7YrL&m%K7@{>Ti5qeBEKNOW-3QP<*)zJr=srVflhf zIhRTo774{0-Jfz8KZ~Tz8DCja@WX%glfnt;qlV@E4Bnk6Ek^pm@l}OA1Zb7jrcdhu&3A(XNnf9Bfm?U;y zkv-V>lHoYfhNq=a9li^$qy+b(JJ|>*gZJYdtMPn9Jl7*Q{iA9w?&y)glBjLb)#(Ea zpTw10R`B8T$wBcUlG^d!Pybg8l@wfw!DUyetE@cs^O)KSq+iE~WIUe;BOlD{wiA z`;Jl|@R#s`b4)?XyT%&2La`t8T^Oo1PF?1D;o@<>uVaMD6EAHbrRV9zPj|;SNdDG) zE)gzzLY)K;v~3_m7J|mn`*D}~&8IpdhoqmeLs@Qr6@<=ZUc0Hvo1%OFRM1JDxCQ`V zP{hWK_})RF4tMVd2+%E}E00&>bn)1p*_w$D?$o+VP`Xd!II6TM>qM!kF+2n#4|P!3 zW6TdlwavNU4KGJA-C_f)7UP|spsgV zZ*bPKBs%l-tOf>5=WFDOEv~2?skD01VfltA=rk3x6hwq%>GI~VE-|q8g0S~!r<^5e z2X~{V4(>C4R-WsHo3$!pc#1u1No~Kaz(~WmIHcUCBo=)wTqU|@ZsOyZ^THLNY&7~I-LK-n*Et|Qmf`iNJesZZ>QfgTF~j5b(~*q} zKNhE#~wJ?z@eIU{8?%K zsshkKQz%kxlKUM!#>HPM!tYCwGxz0(fDZD~%;yCu!_Y3h~WQUnAm`pbo74#uf0zp45+0axufH1%q~%!7>9Z8C2Arud9!k5A z!Bw*?0o9cEbJ%l%@AqfzmBmqYMLOXj`T8Nd`=O4e75se?hH^iS-_9So>JkBu zlLH3;ds`Ebz$37!YNp*Yz12-wap!N&Yj2K`%iNUt#K=#kG}UTyEM*$FZ%vEaURdeHl61?ZrO8~F}D_e=L{2|hg< z_##s@kgD`D;_o@*qZ`zs{uvW56*Xci6hn?dB?k05b0NNMd^PGzr-d%^a%Fe59vmr+ zKJu#2E>bM=#h){hd{$kHEn93CAV(<7%`J?$4td{D`NZesa;GFO&rKy6E*dp?Y*x}K zFOnku`E+>(=>%?=JyZZd;m2MmeC7+Pjhd7vx4xWHBQlFjkG|VJzj}Cx>gh;Jn6JOz z`kX*d9hCeF!)Okqy6@E{`aJVtN3|OU=VQ<7ok~1HhJU(>$@%4()849&6;9DKKDw$6 zbixp@#A@68{UMe@30;aoSIE=m1h+P|Kem2|<7#|)Cr9n9Qt+Y3p~1Hh$&%y~+yhN* zNDC2szo72t3$@f2YEpaeyz$_=GLg?fXjxOD)GGYkms0&^?i!#G(6tCid+UeZhx!N1 zsb%Wwwn+woc(?lA;i3}@J9!l$e zhr%BwYjf2G_UDl_{aLp4Mw7G-@?6&vCo~Hy^=7VDGLJz7Q%;gc5Q(V2MsoD<{nEFk zlf8OQ(lc4sPK-%JNtZCBi+>~z*2S+F_ATDN2EL!1EQI*5>SekJ3EIfuy^_EohOhxX z4iz2`CR^l};)Hja^t2+K1R*gtXp@KuA^g|fsz_+~zoty_xL^VBYZO-4NE`|_R`~0R zXMp?TICIA(|w2MB*>pSiC5 zgDd|yCDUym8y0<{lipd$V0WRvnG5?t-yt<2a8Pn9MU1p^RgvDG!{znJ^=9-(n^@y1 ze&9J$Ww&P)X)OaCR1R@t56bm3DhMm>Dk{_Rq^n{S{ITALgJs{z-jGjdp(>Q1Rcl%8 zeptC{f1&jWYY=Ppdw$4rgSUB1%|&oEh#mbW@8L?neHZTk^{vg3)Uo3qd;gsSy4@Kg zSjCu8gZ9L@g)92udb6s4YK=9q)7U-9B;%<5&`#ldXBup6v-GR9vJ(;Kg zz4=XQJzUMeVsFOFr1`umhf^kqV9PXp@ijx9>8+8Es$igC7$b5aC*n|rvmQ*;{D*_{ zJ%#vz`Zt7y2_43!XXvYPGXih(CW>${y#_iMUV!x2Rqvn*;IjA?wehMFLfI1oy3v1r zR`q+F7|B%}btQ?oJRL?;tOj&aFfSDQeogy9htn3X$3%`*SIA7nFpmT}w;Ddl5c^VS z-0VcG&1kH>2DyGH{o+OhHt8SwewI=JbyR(V9@{4##b~6jN5o&zz4ZB^Mf<(xU!{Tf zn>fJRs1iSJ#hS@({}w zgy;y;Km1|8S?HttrC#BgNDY#Sx$G;1nSYt-#4L!FQ(OIw|ITDq&;r1K+qlKcP0_`v-BWh9@b{2`!DDX{aYOXIfkJI{wgE{|9u^Fp&n!=L%A`4t%~0c!OV1 zuI=n55(U8L$_f9xAoo8COYE=X)pRDleTCEj45bxB;A>bV>dm*(aTNF_ESO$OVtqiL z7{Tc~xqd`VZrY{t6Y-QT)x!Wx&s=sG*mX*#w~|P zF{_Er7lCT?P+|tDCagG*grl(akx23H@4h6J59v!|X7urm!g-$GsF_z_o`#u|HMHQ4JNwr^KPYDe9K z_#XLLbiKcvZ-n!V`S z;?=JeAJ#vk<+@G^??lh0xEZDyV=_))kFb1tb)e#C%Xae~-LZ3qTHoq>XjX0yhR@o0 zZg-PdwXEHeeK4F4m7S8(g3v{a5y#MC)Ej@k$-d5?>Q>XpSow>f{3#pGCob`;WQCsupqEu*jJtW%VidR8EpdZCokSieuIId1T)$xn@*q8`rXqu&|_z)ZvF55$aR z>|2&i`fBuceJ0cDTJQn)evIzFe^*`t1ASNXX30`FM(7*lLZRJVR<3j!2Wpk?a zfS<>Gq2y#as|L{u>eVJ^@l((I^neaVrXpJJvo8wkdVi`5HCjvDak_aazdT`hktK?~ z<4fPImP6<6eJP{kjsrSL;XQ2`l7VWycc@l7mUVaq}#N?xaHhhlm;V z?^X6%D#oNT>qc}{$D6=KwgWFn+r9t!uE6+al;C%Yy!Ka-VpwziZ#{m1X zXX0_r1785;@7q5zmt_VCkB-PP$S>%L8k2!(*HK3Cd z;zHbB|NUXqj>f%XYHy1&CSM-6e_*wJzm`xp{6=MoiR9rePW-vnhF$anm1S5pp7s`% z7oG4g0V5nDxqjOvAL}=oVmYp0Y71`^3Y8 zc7~R2Y#W>flg{UJBZMsoq`S`z65V{A^`?#83yH<1kr~{Q*G%fEd&9*fH#lm#dt*DfF4%<86VBCSr&eDdE9?ah>US{ zNBN=+eRp$}`QH+WY$*tjz(l0I2?*1(=zF=BS7|cS;T$2v4@G$x{_4C?6wfFltfKd= zryonB#fT%yU$NZnEoa`!RHe#_7+;pIm1bM`s$6KUi7rq;nO)lO!tJ?eGqp?DD zj=`2ve!to46UX`oPhUOKy`llpUa&3#$iSc29+XdC!UqLMgXByDJ9-xwL`**P;1`UJ zua?qY`OE+3$~X-j&_THi5*BIALBCsD!H1-#Sch}ro}9wDGp~Z!8Px@HWa6&)v)ixH zy5;`d4L9)dBW~FjL=VAtBReGYBlt~dwCvQ>_)#kY=g0nB5@sVT=`UCVz7`JIz`YTY z1Aq62&1>Yy$Jz{D&1NjHc?q!FmI~7YAj-%}MS-e(&6)=$)85H2&j2@?Fxs99o_S=yc zqIp6!5j*co$f_L(W;(CiyU}^F4ZI}=cmQQpNKAM;7Dab?^F*YZ7iYipncmu9ExVO{ zT*c?qn%>q;+tDmMov0qxUGE=!A}p*32t{8{{>T$ghp>04^vt|I!4^0*!7JB^AH4rn zP@WNQ5MtU3nL`usK~o^SAj6@wdAAftn&wiNCY=Z$ZdZu`T-pe^d@6(LAehaWFVQ~)|loz_;~nf z#MGq3v9CFI1m~#(4(UfV%dQzqygdwPf*V|CtTrz}%G!X>ZX@I0gD3u8O=+4mYtJck zQf6$GAtZ`RK0LK(@z$pPa4HG#Ug6-JI4Wgegs$r3ZD1&Q31rULW5R^YPp-irx2wR1UuhYNrSedb=gw znI^`myKFCgl}|#*08(d=L57pYFp{2vf_2Sr!=Dls3y8i6zoU-y99OWwk5=I4CD`fe z@_0Zu+jp1dpdiG6ur6*;6*;!s45BK#ah1Iv3`R@Gvisj$HAJa?eDiVPO6XyOSGjj3 zw`Xwk*tb-isSokno~S1+dn3F%caNV7Yz6i1d^_Tvc$i=H=+3ZjDU zDp<-mC9i}TAF@(Uhy*%mh^1p=YwxouNsd4%2^rPyF(W@1X0avktzw@CMQON#dIuFL8re&&iJ7iH5X9h=J(6Y#S@Zha3)FRk|(V%7b6c0tjzcMnWqAH8=v$bq{wCBN}ma*q#hf z@IuiNIGVC7#Gf*C<%a0%AKN^>ve}nwe9cqbbE$s3We_^pq~WcR^qX5RB?&DYHU$-? z7jchyEPltxMqB-2owD;+ZwvM{v$VN^Pz~*Ss^yg=kN<>*D^a{Z$+gEXE%!3fq?*%> zvwt6G%7*rH;6y1hE{kW0p5=|GkY^6)qTYjoS)26#8V^>CR4j<(wco_d(sAS;K&J z8_8Ygo_lYQ%1;D!fxa_*b;(ZTeT(HEEz)I1@kYKS=4h|QrUcjpO?0FO*O}iXu zmn8cuPs|#}{Jb!I7W17u2hr~=6!F!#QRv;NW5M?)lLM{_ zFdM}s8!&qP@;~-1*+a>?0_fl(AP!#HekJi#jmlKb?H_@0j=V&9&r3%C+${S$Nb3Dk zn#k?rNMA4;&`I(`@ex+8*3swn?^uTNq%qW z_PpyhA$foZB>w})u5@>nUfi#a?T3_zistHtH^ZNTs^#M7d(sp*n90U=Adds(vwOW| zm4)c@4&fXp45pQyuho=m>msgPzagkX^LjE{@&+-v>w2>$IN&_swj&OB%KnzAw$Jlt zZ=HHixY=rX@TvsYJMY3ii=RJd%0JUYl~^5}vH?0th^u1XZ>knG?Ww=7zRwO_z7U{g zJT5<9&1dg&+bPQckFlR$=xErTwlr{Lc84Zl@6GQJ^!rU3Jm(Aep_IwZ?-YIezGvoP z&xZkJORn2G`E}=xn=QjOEZ*Hj4)%F-xv0E+52(=P<#v?Cz2Qh3^kO7wo@znrd6@Df zi8TA6>&`snKqs}EP{VwO?F{sJy&CSvEe)80%H88HD!SZwAL^&aqvRRpPenJ!L@YM} zVNPCYK`zAc&4(5-1R_xjUY*GM#d_hFb?SkO5uV=ubEnC&s{gE$dq|5s5zlu6hf9ub zpaL6qgsa&6^}uXus7#aAZPr-M>yjOwE5p;3MzVMR|0E_V2;~fCD|nj5#e`wp4;R7{T{#L`1<3+yW?{n_jO9nYVnZ{0w#^QMUALX_U!XU!(x$w#P_2(eB zmmI+OO{wWvf8;qn!*x|-=QcfI+&?%UE;U|>|MI7qP*j*TOiJvbK_g@p#1!BlV~*8Z z0NzNE1I)y{F;`xy&(n8e@p-Z4GRyX@^O@q8G{1hh7(|>lbOHLN0qJA3f0Pdv=lf{T z|H&=4cMsdi=MeXHGXCBW@ylxMsbLZ01GCl>`4jLsC17C2Y=8YheZ2LdX7lTv(&JU) zoww`fCr0wQExlfFa6HY?b=I77n@I&Z6$q1IPGfc@_B1{{ZM^V{(bX1*K84@QBch6E zx0uyrZB~%w?wrl7n>)oI2Q#`5w|pcJ8!kFA|Fl+iu7c3h$We#(^`pCg%9b1Ks5Yx9 zP8|1=)0YRiJtr9n!!!?LZ%xgm#RiH9vlzRmgsIiohgRAa{*=}%r*>Tou3mnr`KWy_ z=q?CU(db)K0}a>6F)4P^X)yDdP~d7QnU>%lyuDoaN1$UQ=w)A`417ezZB*c)G_I|7M95|SlGwkCJ70tE9AP#OfagHR9I_wFZP@1&${YSj zE+}<+HG2BPcV%}qK6k&{g?Tt51#{;aNiS;lK-683KISQwL**IM$2lL-f}Ks`w5avZ z#2ZGMT_Z=epD#^!MR`0Y?1JPGSV{1((C@Pf#Uh9wNLW1BnaP=TGPqZD+oO+Fmef;3 z>H6Ig$w5wv?xx^WRgi;@T_nsG3>kMUbkcE6&gYNJZ!>_5llDBn-?SBdtSxZp#2OI%6 z7qZSsNny@GyV5mbhUcjbcM^v=U+~@ajw%S%eRKaK_M~Q)XyMS-ZCBH?;?tng8rIYOpHEXNC0dqC_=vyW?wqvuvX&(>2a^b z0Rh3wto2et@1^b${^e%~tvh?xnm6RC%=t%~;2(=ZRsnPV18T9?^t0|y+p9ybZ8?9x z`>5iU&bU#o_0aZ0;St-GrCQ%i6$rN}LLU&q7xCtRF)lV|XERslQp7?_!k?`{*Wnu( z@1);8e~^}Md^w|sJMtTZ>jglGBjFTe#voWlD-!k%r(Jcbd)!7ZI8>*^2L*6F@;q$< zn5kPT9W5zefE>^UASILUTCr-u{oDAFBz*)stxvCnjxfOK=-b{R3sa5xExWBs!&r=3viL_BJdt&-9)P-h2K$l;mU984rZ+h~u`@3Pu4FWJJ^ z*S=1yGB z5-=$g0k=roG#qobO-{q(%@+Q`eU@Dbf*bejD^KqxUgkf&>C!q*Tf;@L2R0#Wi@6>% z|FGA%+ez$8N$keOXU}HWxyC8=f19q>1@ZYMYMV0m%19#@m7Q`9bM|~*~ie8H4F(L0=E#NvoSR9D zO9?4Z3f958*GXu8MP)9qQV|Nm>!EdbQXtlb6_b~41(_0e5Rhft`_ua;*WEN@C%R{G zzvGU2_M*E!99BV?Mu%L+gacg~eN2GL!0*)YOF}IxH5X;AD}sJacb@5c^^;HXPkX~7 z$k6TqBqTUij}&0QM~FFtDkG=p4z2hd`rsCyv)fp!y4HDums-3}s*;LgzX*ezvc&$B zw%llJNLse$%(R`%D<{=0{+i>qB<(jNb?-1$iwcIRFAA3(8*c~1C`rFwjkRSC)HOf#);W~X-1s84ue|2V+>S#`U zZu!OH{A?KrEepUUL_8pvT89MHhU}V02S-T!2u_GUtA8xgVJ?CaQn{pSluJFfJE?9{--Qi7m0jEjj+}6O}$$Id5}Ciz??qfhF%t9UX0ZKP7-367kp77k z#qyUXx3}}{%df`w-NCt57$}q4_#tAZjH#qG5afVcA94IsAXbRzz}q1n32!cbzk2i< z^n>LL*pnq*Xh$h4`-iRa#2K@=yaQ7UWE{x$H$sRPfgqET6nw-_&*M2{PNoOkZ+_dS z`${zGmDyb3&wK|M5e^QoqUc_m0s6DGAJnfjIY|a@>2vC{wNK&}edR%vmgVP0UbD%8I&r3X@&b}F=w}6+J zd#J>zFGqFm9lyVljPo@u6Fv)8W~!UhC-xA55~PkWr}F(g_VYC{+@aT9UhjHDEDANn;nkY=gao%nKSf>&AP zW6O7Zn$TY`_f!m!r}7>}7DjFZxpnXvEN}J12|E}R@SYR&dU(vYElGdf-n3X}%YfjG zWY6hS*Y-j*K#GUadZp`FM5odh-n2x&-oAN)?~|J3covV{GFjSWQg~GbMe?`}Een`T zDC1Z-kh3-4emO?72i8sh?nMdfWpb3i}zU<>W-ZXMIfGn zEKkR*PpAiZVCdM3+PkcZ?%J^T0x-rBbGCwDh#`8=9XhNn|DPrQ&p**ykF5U*XWC4i ze8$v*`^NEYZ7!)7*(0T4?|E_T#Es8WQQPgWU%oRfh)}BOFr5$gP~!;Wm(b8J^>|;| z@t>Pq?=2m@+zKiRTy{ifWVd7B0Gx3?L#9jOW9;Fb#ODFju&}6-k3&!;hZ-bKU#@_1~ity!_USDY@pToJRlK^JRL21!cZC>A%Zy zPf7gsz9sFke{@=DrHzl?-4(vKqkeAd?@{LqE{7QfDXQx!d32Hk9MT5CGOEJx4$M9_ zAB-VOpkHa9Kn0BVava}Gi?k&v){n5#B$c63xTkBx$Gt)d**B4WC%K>siK70mlk?xV zKrj6@I_%wB8XLgzIXsu)sc`!tkErP*C#!|)A5Y7EDRVfx*>z-ff9V9|qkZRi1q-%w zX9N~l(zc$BnDCsGb#$TSTTT?2u7D~&VJPoH%9J;e3>$2{>gvD0qq!=(nbU10#WZB< zeZ>NycSHo1K0%GFEMxjdkb?$)B)rwRNlHu!QF=mOWRw51$9-}%QYA7>24r3+R7d9Q z`XzyBfi1Nxl`7MQ2X)Hp0@WW3ta#;Y^Ne@4zU$tMn*E^U>aHn!^svQY8yW&YJ4%Ye`%HnK z^2jmQ^M7O$(2L&RXY|tZ&=tIWB|kDgFtN#>?HPG*e~pB*V|wfg4IN3GTM+r3KHbs_ z`^aMGb#JLk&&W?YVT+N#;F_inu_@l~LoW3Ha?w15`z$g8P`n`hpHwVBqg=cCgGk;( z#q!jhWBNJ#bYBYPKK__+XzdE;4g^VyrCQz~zGOav^q<#h_mpi~b^U-oh9 z;4aqkTK&2_#lUcKjaqT#eZ!&ZZ_JnSZW_Fgpp|X4R3qV$hy^*QfI}L={SG4VYHQ4+ ziKDIU!PWC8@-C}P-gC&T(FqA}^Sd5v8G7O-;P|~ET}Y@i{(wuDkJ%odqA{pHLG0k_Sdd(Mdc zaH18Zl8Ew883DIc;tP9OMv46ykFyXnLjaz$UD3eiCZp6q35!6(74u(ym$k3Gk1=_~ zbZ0DHzB3G*J~3g4q-*Pr*9DIHvuf5IzWBE~uEs z(m$)`%{!RI`W~nlZ@WJ@o@cF3diTD8m7uh+PWgB?$SDAgHU>%h$6%32ExifrnV48= zk^5ej-}x$a9q?Yw&<}^^9Mx_KBxZaF#R-xCT#hVwMobHxq{i_%{Invf|i8nwFGA9VxV-1YvME0Lz7Qd4JkW!-RxbJZ?7KiS;T09N0 zl(&aM4`0k!YtG*5NC8p^q}Jm%(h&yl=WlX~Gl%R<%%j9N$@wh!U70%sJHZS#(mg?W z)`LEqfSAxjf-wl~*(MgDO~(bt7!CCn=#iKZTj%t0PfgRXxSo(+VhUJ#SY}(00gk|4 z2{1-I#0_Kbd9#0T?IlC!(6;CAT&yCsT&x?u(H|!Wt)?Q+9@Y9lumVU8|RoW%SIHDq0UXh04$Hk8&P8KwFIcEo!&dAMO-I6+q)iBL$56i1qz+mUV& z2xaHFLEBKliU<3-mrzAw++Vsd&x7yq`S>8MxIp}67OhA8iw}+{D<4%07#BP&!h7oC zqUxb(+dcFI^Nca)`gb*UoxT(wn||YP+Vrf7ZQ~ohmk6Sss#MDMJ)e=9=cuund=n5h zbZ8-dv_H~Ly{9+XqEe|Zys{g@55<$0ssP}Z*=V*OF4r*GER735- ztfjJ@Bd*og6{6{U(SjRDCNqNDJD6cO|xPncy zmi9EI%g6A=E*Zz${4=_zG3TtZ537&Dw#~-s6{bS(s<09!EVU#~55#cy z-A+Gs4lj;!Kt1^>ph{>@MLdC~My#HAHu>U4vF9d>4vN8VDEZOqlknf-ahiec`YzQ$ zjK9R8(i~V)_Qy)+d_g*Hs8ACqTndH57KFGc+;fKsJyAFi-9h=H)S)k!kOl*%ebJ@7 zA185RzPe51a5GkXRHW9fMg%R*<(F4oBJ2qJcPQSr}S}7-^-YOzYBMy z7`GGDLj5dd-!LqzH<(nt0Q)NdF>S<ChZLssoumPV>BKkV-O13_qk@7w>`C4!2obvrNk_b^1x^|48E7Dj!tBF#Huhli6pU4UsbCf+9ZWKto?G?HKX=DIr^>Kb zEGuwe-=cQ+VlA+dcZ z=~;p`EI+Rp)h|4=c+`FFp0*v0o%=gd@uxfznJkBWR-I}^@B~2)O8yaG=6x{8Ff8+9 zkJ{$o^=@+YC62@KGu9vntX9YcY(WSO;9Ny61d_g4cS*UA zv(wATI)>A@)#ZE4$RHfA#m8G+!w_m)p^|wYNWA}qRcMZ*jV*!WG>62Sg2~2gAFBJ8 zGx7Y(9oD#L&D+K@R0t&w@OJx50rSX(hv$g~HzsK_F@0!Rug_1WFK(p&6dwGt-J9wh zU+c+X=6~EE2e}92{eB~@fFO7L?Q7O(7P__&+6t1u8axwlC=mwmk^n!pn!R;0h8O}`GGOWxhn7Lr7Gx9 zMuPhPxYv`PEbRI|A^J)CBU+mR&#%R3^!zND+q=X=A^jwOK}=NwA(`qvsPJyR?;LR7 zQtMLcVz?>H@WaLDB2(NI5E~3;8MoK|!@UKt2co4273l^ttQFKevBtBia{2tkjrCzW zYNunPhM{^DQC5T86Yg4!da7ywC&U%S_J_~=zr~_>!=Y`PCka^ahB^gr_VP^LVt`ONR`U;YkP zZ+qm&t;3;~RD||&%q7a6#9ju*6NyhUT4#uSHosq*&T*}nFQT{m-9}ET;`>DZUE9(Z zKod}}jb#4bA_LIj^-f6(Qy&?kEOldPto4xV`(n02-u8`gFy$~`=kUJ@0?4Q-NCGPp z=6Q{=SnDA2_{ydnAAPE>g56Y7b^j@uFPxOm8{(5Y{0PR6{G9@HrT|U~QsG(;^AHhq z*28b@cIHOP@Lif8o{LGX7oXUiLKT&rnRPb|65LFsegJYR&@PDa8a~Znt=N!MPaI#A zf@*e{qJ}`{G1k|&$1iA6&hWEYtCBa1CO82Kfx2cSMbQQY=?FKl>hjOKB79QiLQ;{g{^_L@NIy?&df;5Rk_GjhX-7XL+_Q$<`G5;;C zCC}x92UGu5ColfJ- z8S3UwR~sP^rnEP{2lIkYaFCw)yMO0}i#_Nu2EA7Ltb z1#(Ja!ic-!^A0Qb<2k|mJT=_&wB=@P?mu?cJ3`56NQBC7zO(eAb6~y%FcNZj`?Kyo z90Y3XsGN&g>NUzK)TUWdMJsP`MO7|_D$I85-U-Qn8t7%V2YaA49rNKE4xV?aX#KZq ztm9?5UU^wRTL1g{nbT>P9tSHPN?i@B5VTrE2MD2}5v_IKC14NsJ)Ch$6v0g%)O03y zllHCoj_97Ony>P)s}b69RXhXE01JRk1j%Vt9CTVyFNTCmH!TN~+M~-`*NHEHmU@vrc$D~`?i;=FbN|mRim(tDI8tyQoEYu6w z7H7vR%h$#C+z}wf!+f8yP%>ghh|EySVtD>YAfvgy)+PH9f5@lP)v)JDU)aPp_p68x zJbhK@d}aRzw!ZtC@3TDWf2I$zl?L7ZH5gdPP8(}{c0YNkEHjJZu9GY5HPmkGyChYi zn7abXXNR?q)TLO)fz#|(S%cx$jP}Out&LPqizoCi4P~}6jrJlW5Z%TglQkgXLtM4G zi=C@|{HCW$UzD3wXZN&>9YbyS_L`sZeG&X@Soi&5kOQJ{q)9&N;0%uCs|p)8oob{k^f;CHoJwq$P*l)R zJz2>YmCLEs@*P|*Ao_uc_2|12ynr3$m3`KXrZdGjwx4*FlTZL9uic{hK6u(>BwkQN zUh&v-VvtjS<}S=SpRZ#r|6Jb77c0NIE1k2g%KvF)pLBa~%AynzmMN&TnwxOi6xtQQ zF_b_8!PQ9bH|&e+`L};_?i~}VA6cWlNv9tB?^i|0Bhk~$MoY~M--jtA07(f$eGq0p z7oq$H*%!Av`ds9n>x!Y9Rf4B6$cXI^Y zs)73oG@bkO*>h3Y=h<%Ee!afwaYL4%o4eMRglDpqvhA{ZM6vgi!#C59e=-F*XfHx^ ze;ty8g!4sowpZ_LySz2yrH^l}#;lzl2qKXf9dDL9eE%=CCUE<4CSLdET{6ZQBU_lXju`&0c^d;rK{*u==3cqpm z!Id{Lzr&fc{qvvI-hQaoBzMvwTk96rRK|5GTm=>S&!gCS3)wfab9RhuDKf zn<%tosXy$o`YltoGl{vae6upffiQD5UvaEGuR@-ruAV9|clMC&ekL9(WN0Qc{U zHY*vBQxTCszMFp;c0Xtf8zOYng^jXyq)a$ex%kcb@x1MHD2typ$jY`BFFe|__0Uv} z`QBZCNf3|L?fChju;xM3#Ww2IrLp>+SBag!sN=J-*asp5F^yf5*0{NyO+`iv&^`k;x?QcfTDnea{@?P;iX5T##y$t6{`0d%WxF9!+ zKP{H1mp8NmhH^JK$|eZ|MDE8wOON7((2Xi2-;mLAf!b$(}J0*{0iXe!mx!4F?u1r7|C!Q zS3set4y!{HL>&dmx(Qztj;Fi;iVz2Nm?acNhDnZAV8BQS>l0qO(AP{4QoN2g2H#e4 zok5x0eIZzrrTQyIcIw@};q;)n#dcqUD@G*Ydwsuc2K{lpzjZP9I`M9Jd)7{=9e)NF z5hmCo2PhyJ)93>S_O!9*X?4%~;_}d>3l@sEm}8Tz^q(8cvk#nnBuz(gM*_`}hlFAS zeo|nPFPL7G|CQ%DfFz;lV9uvqV>^=HrH<8kU00(mit(yV#%d!T(RZB9^6a$|zc;sU zY7WCtrP6Vy$4=gT8rAN%XIMStU1MUWGMYmNIf`-qsO|-Gpx6il$5Yp^K@9(y9=pj) z(jPNq#j5!}m71*J${928K45Ya!Dlo-`VAPi1;pt)wt4q=XoG4ru7=3@YLfIvueYzS zojfXjQbSt3Fv>%2^-eYW5F?m+n4gZArWB;(4|XVthO5x?XPCrfZ?|CU1(u>ojQ9wC-n+O@3wBY%iyGl5kzV1Yus->myv^^D>kz{bQUK;^43cSsLQkZKr^V)0 zT33owNo+7q)zgfu=xh2{y*&O=jbAg|`OB}>RRk<+N|H!%&6A!Z`>RxXx#4zyoGJX- zMUCJ%1{JH$093o0+VnBnqGk>f6ty&nK?5b`X@v-JHGG7*Z_#uA63tI$E!*;N=sM=R zej0I><*M{s67|=i6&r;*Hh?3*%#F5(KSHq|L2{<4$V=+$qs7nbPwg0}gdQ-;QN4UCQDLUfC>8e>=|X+Z~@NtLTY5zZqyN}_Ww`LYc~&xL`UAWR;_Y|9gb zb{w9k_U9yR3!_u9wREb;>9c`s9ixqL3FtfY`&Ar7fZJZIRWvmoS^G)u z`qW&)Oyl(PH+GrIMq?8~bN7M^pFk`ET8Y7+qUAOZnu6^=lor-F)QJoSivN2?apRfR zHErqEpE)TxRy(rJg_pp5NT|Xzd(3`zq+{y`#0wblH)4D@=?vVIe_WMT*Y}B+Jgvo) zsA=^4#+&4Sm#K&(VSG5o3alU~6t=~IUsa%5<}J|+f#S^q3A-%Y-?!=GhdNqSn3#X} zc+BE~GK9!KvYlZ`SSvvA=VMpD+u~YCYzR?L&;pA}Smh%h8sk?U&OU;PijC!fN`Ptv z>1h~(I2m#ms{D#?|JZom;weZ=VtF3dTbrm%MfuLA4h7}cK#GviEuc1mf+M8jXax%n z3C@}Jj=C^uDRWxdhYDOVj(uNrhDF)0TCBQ@p`u+@XD?y`0Vs@Izz3|H_4SB|(eu;6 z4lj!rU!E(#u~V8J;^VB8BcaaMz+93jQaKIK>^;$m5l*U#s#w;4Y$%4n-k zbb0lXJ*(3l{+^V`%Tnz}4n#sga=t$=HypWqa5{ZLTRlv}6C^sn+-f$zHTPaJ)t}8P zoax>owd>nDt4EC>CjVv^5%0UC$1C3v!aMP|PjLIAC;R z7P47d+qS!|>HI9@nqs?^Is@q~K6XFnuemr)9nIoUxTmZLEgKk(n|hF6O73^i^b=$= z>3>{vZQDlUO@f@V(0-xd%UW!6t$BMQmp^^Jqp54v6w{@0 z;sK}ph}Ii(Eea}JSEfI2Q&ADA2=0^j_Z=LUc#o}hR??~o691I&mDSp3r)dgL^)#8s zRc$=qkzF|Mu@|2a+#d_vzJkSIdMc<4nf6{`qpLZhD#c7^REBk3hC9B*7+927n- z6q#|OJaIx%s6(D8d0YY1VMQos@j?el>d;u~|4hpu+L5+!r^h_B`Qe|xrZQR1WTo?T z6}Iljc_-v@92r;5vcS27`rv)4o1%2A`Z%T8e|_}c747US|ISUPy0}XbrykOlxL1+j z&>ga-vVh)>z4@_-kt%6GUH}88{u9iqp!>R ziDM=ma4qTK{>3m=nTjOe}j_`@erY zk$*t1{w*5C_S1T*YAmp@_vVm#*=+}UcsyNy{pROcOMBnZ%Wn1GHn1i@z1=_7uwy3I zT~<+t3D2+t_2TqpyU3bfL>xDB>wYakX%FDPLc?;iD6X# zyMv<9P`;T4m2>v=?^{0K^iUeUlXZ<&dYS9yu}urIaa&iOS8#%4nL(oF3YBwew>TCWG66I6u>1@efB!Q26uIf{gJ8gj5I?#VCT8p}^k^CYH^ zDZbqA_9KWRW4)h|J3LF&7icsq9kQ381gwqOj*WwmxBLAQP9!VxL*MugovIEn^Dk=C zsEb`stEQP=VId>s0ZS^Z47I|T*Xug4G~695L|Vh;Cep=Ea%-M*;}HLmBu);~t6J1w zmmSzFhq_E*6^Z>O%W@=R58K%(bz3zn;N@cC@K2vny^{&&*CzAda?Xm*aY^2Bj}(Rq z4**Z#>|k&g(&Gwp;ZAd?kd-&A)MxISF+@wdSoZ}HK5ArtW%aL5=p>tpAv%l)Y%FNG zm4kJL7!at4C}ls|b`|U>`MqW*$DhSj$6X$f9mIyqgHH)=t;k;SAO^1$CSmupZQ`{_ViMfg?_FJQ92r{*M^utKzb1Q)|k(MFjY zpKOb7NbKQe0M1BmtmL2qELqxP_vfja7M8m<$DL#^mvNDCWNwq_DQXJ$=x_@uaDbeO zkR&pM_sLuA^^qiR_|i-+o_E{vd{q8buML+m|EToDg2}B zKVskUKEWM}iBL%+9hxIAu*%Ij+t6S1o~dL;#;B&P0&q4U3na1s^MIX3)wyUuo#c-q z4^xxA>c4CAw$<+{b|0IJ6sNu)qWkj=fGC9HL=a?{n26a&P~bRS4A0fCIJ{>yw4N{I z7LF#^-JupDt9mt=b#hxvQdh%itAz5UZ+*ki&uU90c(+w;15S`5*dzn*lJb&V4= zaY)p?6VZAg#{r2LhwbY!8~(k;C!*=3gr4UMU28b(cI?@#)kn593joYOUWK#-R3a?_ zaD5o4eaD)Xy+56Jn_=1~M0L7@utqBJec>IUzaFAR=B(F24yZa1AGdfL`+ipE)!P%< z4(W7`3}ttHp*uH)=XUPcL$lPmZuRlGfnF<+gQ?rd^_d2Mjzr~jyIo?>jQ6ZY%Tk`- zF5#40I+`t7+0F0ty3$#m>?+|7L@AZ%$D**&Y_)YEL$eFV(?X4>ZQr*&|Hx#ttK4Y) z@a!#`{@*(i{{Se1BOrpX+RPjj#Fe#N=e+E=GZG$9J4xvE^7DM$$l#dO-=qWG)3^-zz|jpXA?-XHpb_2?n(yI5NF5BY~^W*QAns{Ky=LHmX2Q82~os zx(#k){hX^0|DE>qX$$O2Ygido?6Y_|*+!cG@A1aTfY(VbPZBOdIkWdyY6dfeTclSDGZ+tm^8$Zp!@1U5O!&fDAvgp zCpt9h-S1p#?Xo4YMdywr;UdXqJWKu)6hUCwVG;vkXhAD$I+CQUjjE)<>X9sfDY z`c~e+?}bFEqYp0_W7R#*42&PJdO&fw`S?@aJB`sPnw6)$fw<20;EgK+&LB0Cnm0p!BFb2@lIF5TbmKSSZ3jQ4ss0!Ak}PdYup2epnhd zJ@w^t=kc6!8-wTdD^%lda~Ch4e=JN(>$3lWOwK8@*t*`O!tZ5j|NPp2i5F!O#U-{j z*xnQxYpxkk2-X^Ykl^7EGNude)v>@X$}Qq3Av}_`PlbOkdksYMPdJ)d+*!QJ@g~G` z_cfS7aI=vN{N_9vF$F*`0tyUA5PF^cNA?&+`aKQc%v*; zcgL0x=SnBj)c!iV-k7>MCo@I#L+Nvbja6^}t*Akg@}ydcd4s7F~G=*-X` zHWt(y665MCi06&YSDqeC=J&iPmbkG*>(wN_i<_oV`}#8HZg3l*7zkS+@7H-yrz0OA zeLlb~Cy@28KHs05dzOp}88~0%ey|$OwOSc(M&1KCsDwZ$-YfF3j_*Iorh-;y#)2t% zb*ID&r|G_S3O>m=Ci%e!>C79HjPgtmhQ;G9^&k|Ko8E|L+fdYa^%F zGc(R7%4JOq&1K&Xqz#zuVe>x}}b%^o&(m^)i{C*~ZTcTxPsxR%<_>xfIk~FQ4;+XY4 zh>pQ=hl*kJe)=E<&G5a1d%R}9Se8GwYb$Dk#`I?@lfIf$cd;5LBs?7ytRYw z;>zC62juk{7Rj%gOj~!F(oD_os?C&9ykK@VZxWbM<=KN30P&Ic3&nni>yNB>Cz>p> zOeb%8;Tv%6ShQ^a7&U+JnZ2|#QdG*~D42O@T0sgO+Ywj+c81E+#k=Ch2@T%lqCfS? zviA-drq1X^Hkb!Js1NMm?5GDhD7ZoD&-&hCgX#QlHHX-U>gZ$yIOT&Ac6`#-Dx=&~ z$jH94l4+Cmwf}?0MnS-@=-2zag)K|ujCyE9mYwxvREepJ@aqFPwFrUo`}bv`nmID% zyt}qNpbAy``X#Kn$hNcdI=ymNY!>=~99Wg6WV8kdnj-}a9{NV{kK-(a?pb-@9>iRO z@BgsdA-~IGo%$$PdNhW`-*IlV$g(k<0X52df}Z$?Mz5BUI+$H3jzi4ZS5K_DFb~(v zl0OxeR8{L=g5sv(CMRrz62CD*2VtUi~!W!Vna*jWF!PHfA^uvNx!H>omeK zR%hJkc^ z@fi+7!WSu>-4U;tcyE9?1T%vK5JHjiI5?JRRLbl&L3qq$G=~;yX(|%_kyD2q4*r)G z&TZjdV@3)|Oa&F7fWWxDb!(*i=31Y5WBS}@SCeZCq&AwFKbzX|{2xCwKHhloup|%a zFqH@uuA(CS_k&rTIaSly8Aqk*@2a~J{5#Rc5SvG`d8?tD^$%xS?R)O?fd2OifsiD= zCv@&1uplS)l0sn8z48Rn7-g}g9u8_2x7~*&S1&ehj(sI`G~TAdRT865o5v>W1}3F; z$rIC6473*WzsNPGSJTSdF5;RD98OmZ|2XW)3w9G`Q6g&VO)(Y)I+>-osCS;)P&Y_% zxFwf$nf!J6jAvC)f;qYUApwbpTObF;e*09B2ln==YX5Qlv(6*iwlmI$a+p0zR&$8@ zJqyGpi{5$*S+Z<~|eM!AYWAhT?%^ocoNW8KP^ zO?@c~V8;ZZ@dE=Nmm%tngiZBFnQ5C7wa9uLlPi2vN$Y!)&-HPh3#eGDtnuc%bH9%(`Mzeqj4>;4Zf-C9+4?qN8}QgYv2bBy!zjG3PVtuP zvSP~%QQi7)6ac>z!CMu^gqiC`vG?g0VQaCf>dJLpN(yqiQ9cd%@E3&+bw8AD47p~{ zD27SGe!+VqNy_d8GGcZxf5-R2C3_)~|IZKFB$i=Jcfpc8?u!y)yvHnBuMaJ!9o?#Y ztm4dJJX(+^{KP0{Y<~~qLx&%Is2w(H`0|SPw5HFMuBl*WPFEYJ=RSSykA0IU!C@Ab zKpeFppua#YqQ0bWT8Q05;YW+y&xad7Ev(EuaO2AxWORHXVCZd*0G`-i^9>=HZ;E&$gm*B%ys}%AXRCw%tbMrUlY4Z&T!8JM_!7C}zcWZN(H_tJg|qDc@t@!5)nmBx z20mI;NYxcGY7mw5Op^=G>ycbNd;Oo{yEL7U7C!t#PW!8Ge&5lfb3d}Ga|S7NB* z!LN5VbCz1zEP~$w|Gq3{L?>wCWxX;I$KzeYafz0jBO*s}Zy1?X|40& zaz{*KI)-b1v~_d52r~LoRqUfva&xxbxiD~JlMkmubuUr4KYMFC8G9$IYcCFuwUEva^R@# zK=h@HpH)A&&RETQQ+N|Bb&OWcZM+=y*kog$IlO?VqBrY)49^GBZ6|RgL49@T2)FJ{0c> zDMA#1>x+alXsu_@~XccG9bJWa0jY%)dne}7^03VP}Pi1s{$L7u0b^`oC0Sv9Fz*{3}=5*cGA9v-p?sp0$CCq=Jq zyuWmtI&H30T7#GR{WLWCJGN@qh8YJnB?pykU5Oai9*_P24*}S)kif~)I4p08R;G=5 zh$SQSt51(}j-MAuu&nWuuKt!D_J*CzW0o@nW`@C3WF#M23XB_wMQ8j?5b`^cm*2kd zwPl6z%wXNU32R0ib#=0`D`gkmbD3bInFxL5+Hv%uhI@Ec_b_pX>a26g`EKs^KOw)P z#Ktm1ga6FLs%rYt-YhUhYioo;Vd4O93-$zTn`dU5*-05yH@S09(1&PzX_BSpE!pLm zCHhiEzZb>>;D&L$hyAf}2$^xpg4DGd(*Z6ny9eY3Hj24kD><8EraJnD7R~dCz~(EW zLZ4ZJsg{CWR;mdQkC>a~l^&rdJ2k_Ro?`UvDZa6T=*qJSp2VIj;D12(rXUgr>H=aE zWE&JWwx*v~<@6rAeOg9r{Zm=y2ZLDWj47uVv#ne7Cw5(cb6bLb(u;Nf|9{M?VS{q! ziS?3_aCkJHx^7n>ERP3m{Et2>ND76sxaESskN@CDChWJw%P1ur%hW?=1V;YM=i$s0Q2JB`9J_^_Gey8|h z|JJSPh=KBvFu>zbB#1eWzYuOO_)7HB%En{Q1I-%jhdQ%+`M>=Q$)=_xq;`H~ibtb& zp`v#$`Ud-e(b5}$;}N4;ji;=@vf#yI-PB+q*Zr$}miwP!;cYj&iauKQXnu!$kW+y| zXw36s;xRf4p7-#QeB)F|l+uio5jQh^a1~Gf34EJi1szv~?%(bAo?3z}6o%pkjCTHT zFeTe~`hB9x_^X`^>nxMJ(ug$Zu2c$-Wd-xhA8eozR)ku*bJTI@E z8du6b)_?eqOuD6w?x6zn#i{ty{J*@YN1bB-DL`})^2fmCfwn>)4y+fQz9xB+TWLnu z+fzB_GQ$jyl_}JZ2fQR>=Wa5p8EXPRKxwZ=3Zoa|hOqm>SK7lnsB#nk!wESbd!9R{Mo^0;GZ$Cd=m*h(|m<%3hzgyWoe!0Ak(0?b)P{Fx=Rtc zEMy`dtn*D+PVZ?Fc2%3iMEv7<1KL~9L-MaDo|>SgOy;_H<~~IARiRo9!7@4F`*9p! zwAM~S<3U1sz_Ii|kD-hLmJHD5xP)l!hoNa06g|vq7N;Xk!on`TiV9Y|rY^drdZJZ` zPPZw_S`7F8{s9!e6lgS`q{$;@(wkxbrshYhZ%Fp7f}*Ag%U6uUO5fqbLaht1uc1Gz z?;;hc!vwBd;iLu(ptzLY_2JNsC@65elq9wEW7~J1t0+Ubsi;#W`gCv z8XNihKZYN@{zWuQ88m3=?)XEWb5(^^QDy0yy{S>!H4`1)XsXxU8?}Mw*3j#Rjimc3 zKlt&HsI$_cSgrbN4}$Z)H1r3^3XjeVU-`SlY6gi{@LKk(_o8>OunO1NRz$<%ZpCv& zcDF0i_UV^jG@IYezM??yz)*Dir5`@XK>-;O2klA29?S_f;b!4^OWXAN%riz4t4a9{ zczXF2I8nDVr0ISnc+nV8qTr9SH4E0{Q% z$2jFKXLzFO$cSXN@R-iw8xl4hK7XY5KNpd?;S2wq$hImuDOvOH6(gZeO@9po1kyF= z*L>6_7r;LjP=-NLn0xPw3}S_C$~^Zx*ZE3sK82B4Q60;#DZ;a3XBS@Cz6<2`(#&#P z2nTZjl>SJ@^ZOG@Vk%fRktb%Qh=;U}S!uSJSr)(SS~k4}4v(gziJRwZ4hrYT*F8Aw zGH7VSv4BSBR&{X4S!FyWQcaF%hD)nI!G$cM*=N z88dI67s#aFG>Y6ik)UCb`t24{OeP&o+=4<@i&-;f(GjG3AZUojOL@F+^F)b;W_8`L z|NQUhYfalqW=EKF{NLkDX7}u$E0eWFN6*CPxLhQh?1r6r1%l3B?^~{!+a}@0tS8^f z_zC9B^h@bokTX?Zv+aR|kajmv8(3AbGrX6W_c0Lz2@+NDeE| zhs0vrLi1f*IDLP?xbTY%WoPX&U1Cz+9A$mT#!lvamEjzb4SZceaiM)u{T!s@3*N(* zhf|P+CVD>3aZ1yn(Uv@L;-5Z!|GgJBOosJ#HpK;iFI50&V9tFd(pCuPe%Xv}aMDrJ zlVzhg?dwaf&t5H`7p9q_J2a%&%W~}&CV@#;0Q&0Dhbj3xCbVajE?g9R98O6h zYAGI?cUaL;Q5x4%Xf6HGKY}SZ*A1U*0p_kNh99=%8RZ*1(@U4n zft)CC}I7Js>Se_wNDc~?Wcz)~Ovd_nr=+&NGaT-w|I{y$Jry>qx(b1pbSsd1(Q;MdOBoQljond7Q z8VMGWmJYGFPpJnEL^bXBdwM;nw31*MpW4~3?$nMVx(Y^y0dk?Lk zU+)vbvkH&vF}NJ%G{?AO_9cmrZTXYz`;U}zxhi(qEPqE+?;PsA45ka18;}@Z3qlVK zUw!@&yVdP8Tfs8nyNBIw6+9zv`Sw@3BYPz;O7&@Vl^IkQ@6FalA^`)9Sl6^HbyBkD z#Yy=vvS-#5_4O~^t+EaO{k}hX?BULHm#@<2K@JkAi0hK{1}i78Zsl-BFaK3<;H1aq zj@q3!UU$86?^xzkj1d&G4}0|O1)6{*5Tii-4|0YUXYncJo7P2dRcCejPbPB&k!*@d z?&=N9CotUq{U8cTIF(^4Ao6}g3D{e-NWYbJ(_+Wo@yn`XnvL@KyR^GO0u2)z<_Rr? zzE@oV!zshCI0Q@A#$rD^MV>|d(W4~dc3hRZckqHH$&3gMCgv9%>8HhX*Tdhz=Tin| z*Zr|Izp=+NE#Qe)_DGPZ@wiIeRms*A z3|C$VDxUM_+)-Gq@3`BfafIn{kO8d=Zg0HNzauUgcnGym;%-xZc)J zdR|xXyZa}Xo3GyBtA8i8BWT%k9$@?$W`hU*P!O{L*kSO5#sAMAOh^G^PLt8#=l^7V zLc-fAZPh`ySh$W${FUO~96Em2hU&@y)j0uv#==<_%As8xFsFM-cFfH#I-ti)rkxFK zH@lHTSVt9ab9Fa*LAUl$yw}GN(%RL^N0I`@Ag2VAuP`fbjUgu{ftBM@UP8~MVQs*r)pgO+QHC+ zyx8=6RdCt$`&0gEFJN<_>j;S}hRtDNiuMenZARb}8Kr8a_}2A+vqc)6xQ>4-{j^pZ zUXeBA!mU0!o*(Al;30gOqegcQ;5Vozi~mWp7^2z29$)>mR4anPabat-0oUW<9evJR$&- zOc^~J$M4ehl4nLhClFOXkWpDV!i99=f8r{zdI)a8xG?E-!w)uG%mgIcqD^?|J-mN8 zV|2zdP9zv_u_*IJ5=B{kdUUn|iKa+ zNCB}+bAwuV=v5j=nhO#(Ii8r#2t5lne_X{_V-dJgEsAvMgo;|onKK#v!<+>I;nD2zBqel z`%AW>7mG8u^+#@mwfFX-2+rkCJF_M(`g&uZlIh-QssjIp6XeTbBjZzx++U@SpQPIH z)}6;RW@&E*AMQ44(sT#3JaFr~(thA^=Gu3Q{1e76}j`tO#HBqq?uki%>CEn!afIq4*^~DR)4KrTN(VR0DRJuWWzJIH9FNFhI>Kut z;yCtf@XaomcQvPL-rSq-3rv@mpt1 zTj0dC8)A1VlDw(@h@_H*o+1Ri-rN#gXFS`^5qQ{F!2V*NF7$MhPnTM8T1b0PEPRE` zWw4}E2j3vZ)yh#>w|kHE3F;~}-cCi6kiF@d&e~N_p)OKLW#g1tUH4(*b4}DxZfW*I z8!y%7<`o~D_y}$m7z51BiR5rK0x)iNkWnGai|^Pm|n?Uxu*P`-VwP zVghD(;JgTs6^$afeJEc@W2+sfywj#akK|f%^K$z4Ug(jLM9Gp$2DQy2b&w z&BV_%WR1oj%*J1$)mN6EYqDS7)EUI>8lD;IF3EbCBGOj*BtrWN!s!851G>S-(Ku)8 zD~U+5mP#0n!F0OYMM98IB`^0bI%Bp*^zBWNYF+2DWxxr^9SMFOI0>G2&Zy42a*$>}Jot=soY~(``=Z2w z34NiofabN>+8Lfps)vE#sKFFwcrbzQd9{CGE zQ5rCOcl?7Cq0yk$4SKBtLF^a4g8F@zIwReFZOh7DP`r1;zWoteNXEwnHRFw#FR`uj z_@Y2X0J$$5jA;4}$$^_d*<)cNR1&mNfqqPJ!UaO!D#a~{1L=GJgJC~8mIw;4E;hia$8cY_=LD0%ee2X-hEnj zr?kx^|CV`a4epociJ{)Da+JM5PMjMQ0iCWhsT3ItuCRHo6yZ^wG%CEA+PQANb@FHE zPrr%)6_#gp6y~TAXu1Gw|7WbgNkvH9`@oR&<)PW=#u~lmXPtsxtP#D%62)s&)aBD+ zFXKbg$blRv;DlqBpWy~M;1ArIeqQ&5-HvQ-l;i3GPZOrGyn{R{4YsZDZ>?wVowh(F zEFUP1g1yxhn7jiV->Q{Z+%^fb_G>@iqD}vAZ-boIpZPUkEA6~V6UIgMnHI?L@&kwU z^!F8Z#J_n}W&cn*XNl~?7W7-l=Se`{NwO-Nbj?F|s6Yy5~B!QO;U7yi&zlG`D z91#goKfQH;&|~Ky;UKQVm)RY$txo#a)iioL-Tw#`i0Zjlv1_R8o>A6&2i+YUI4}WYg1O26rW}8J>Nwi~({WZUy@-q0UG@VtY*}^_z-^?=9>~iRLe_1S}q7hc8!r zkht>ah&Yio5!3>L8~{K3z?ZHez3LD%lVQJC({3?UH*r4SDrfve;jV-I*LSu2)7Y9e ziJU8N13}{jw4KxYka~h;UT_pz>nM__@V4>Zi54b$%d;x-sLE4hJ>=n zQo|Kv&Y)5W#Et3pzgEajpyJ&I-U`>P(0XuD<>37M++Pss9}pp?gO_4*0lmCMxK>HHOS8b&A1} z!8Nj6nDKF3pgZY)N&u6ZQ)@MpK&zy zt+@t6B`f}=PMw8ltLi!LAcKT0P)RFJmeFzT%o-6L?rKpR4m%bq8$VVN@tH-v)=^(g zy3F>c$33r%x(W+?M~a&V9t<%Uh`g>mi&)nB1PZ*?Piw5G@4usWZyvXrrKV_O$87vb zUK-g25G9!N2v@@OhU1+LF8Hg_FL>JwXP7zDHgaLd>=E(0=}P!YvkAe2tC84mLd1wL zLCFmCtA30jQDFYIUWCYwhMmflE5Vo zV%9^MJkq`XRKKg?$?F95I@@~3Zh!JFd**^{8w+z{qRSxO1}O8OTi4fvw0`O26<)6T z3>EWAJzLgdfdikhA57wow@Ms-k$C@ta0Ub6rGmCi=uyanGdJLa?27gBpJECJFzny( zKXtt=reE3EPlw_|I-4cRM(ghi(y-EiK^7*a%RL|ZtKGH`O}s5Fo|ahg-Z@AEQ#dk; zqWP_yts!YD0S9L>0QP{5LEW7{dY~Y zPgngw!;>^1MTcX2lRI#{SdGquT4COet)~WgA@{z&n@Td^(V)F zgIfELVd!PyU)y+X(Z~0`PW`;3ezZZWd0n#JX+{H>Nl-uv>0_ZM5^QXWs0-Qnn|=!^ z%*&Y@j0x+pP2n5X6zRtI)S(=It_Gq)5+H#NTV;IMWQn>rsBmr~{lm+~IY>EZS|ZLxuze zCc9i^m*eL57S7xS<_w--R=HKB|P839W3?m z!<&KIRlKftx(e@-ft(a#6!9qln)E?_PbJ8NL0&x&AM?}d+plesnR*93ZB@0CyB;h@RhkzTgp<8EA->8uP-ZVWf1&T`Ns)r zIXK8Z?;%~jZx2b-3hN6*!iP?13iS#Kmxa5#zwnaWD4Tn)t#OnD+%!P1bJp4xoPtCY z&vhA%I@2<=2Js2(Si*n2?n~YMqi1eRLxK}0hyOTo7|2P088Xm*dBef-(j z^OyL+->aJ^DXSs;0R_?B;0TTa)4?V-p5jS*bUH2E{cU}@qNi9#=95r@cL2Kas7k> z1YDitBk{;?z4dMXg|M`sIRuKz{XL&EKL6@RC7r5PP~X-09}EwxLR@jZ+4x&7HGkzE zCS@0AYzCGVkWa&Th!TJh;Qg1e)vC_XkdLIMB7ahgndIj+V_HFD8__p9U7TE}s{|%J z@o|xDBtdiK!TNry&zE$lukg%uzt4VniaeGG!hzkys-*~Z#5T|2*B z_21on_p}U-u*~D8oU{+)jT>2BVTQoZ1mSA{kx%uw24pzl{Wy9SFfeqNjfctNiFsnH zbD5G_?wiXu>Bs5mNk870c^rQ_2=EYQk^}p3=d+W_I73ReZ^6J~$)d;Jo$}g}MrxmM9?SVrE3l%~geC9HQ+G;Uc444P}< z133wPb{N2W{X_0!mp^lS2fcNSZtwC%{pbdhN>_E93cJdRL&d9Crf}6k&6F63v%p2k zYwJixpY*HcmKyK$&<6YjV@-Z0TRd{~GSHyCfp)||%4sjo1zut?F5pN(di8A+|Rp=cchiFlN^nV91jllP2-hd^JN&jn3 z)Bf^Lty;$xEkCx)5?^l>Q2w&Sw(T_l(Pc5v)el3g-d*H9HC5zv&=iz)d&s4;j@UNx8SF;s&)vgy zk{Cgew>Ue`Sy7Ew3o@zPG)Z`)MxlaVTC(rAq&Q_xB*mq|CR$8x^NFyF<45a`ptzok z%qO1uOs^-+N#;Ls)@Sfx;-hHFZO}EE5SE)B`}7?A|6*i8o=C(WYLuQG66XrVCNv{vbKlRk15W!y6d`j?FU>QVOA;^w#c8odk|uvqJZKUlm61^y)W<; z5WQ?r0AdgB2?FQ*aL}s0ojYU6Wz;N8JQgF|rZ;Y-_#&y{frQp|BIeXMgpa{>MnzNo z843A^1(ZC+-wvhyd4XZdxk=fe(yv5qX?Qz|^rx%uOg|Aw>Pvw%7_5&eaDou*=cjca zlCMW^397XVzqYS_+SlmC$Z`Y9qYg&Zr@+=P5LJRGa~j{1*Ku3&`y z6Zu2>ZQ;RtvQm3F_8iXe55!Y7z-~!__Xf@!++1OuL zWzv?<3uc{0LdF-qN?!N{d>Uy)O(bNv3gNsy5Nx2iru&$TAoSKwFkgg0KK3vIn2o*@*uv~{Kh=VQ7PEC*Ls@_Pjk{s^CI`QNgRubPc>FH z`Aj5`12t?ghD<#tiS{WW#8DCYeQow>Ie#&W4bRy7m9Hw7SeiSSRXjAO z81)Y)*f+U|{uRMadXpH7`4#~UCT19-eut32`2vb44H*hH6tjlPjSh_tJ{KqM@C^)g zS5Q_H+@K6KPtw0(r*8j9wy4;r)%48LC^`E%QD9f6oAy|j=C$K7SmAPcTzVCHi_lKp zy-~UbSVRz*I2%+2g1KjM+WT{IQ`AD#`-E#pvt#$0r(!Y6`TQ)nSY~3q#qQc8kOVvE zE`xr+b|OAhZgd*6M*QUzb3)VwG|%^jiB%aS#18K6<60>jt8grUUEOown9ujO#Wk&pIm24ebr_&E%Q44;scKB4cOsc2PjRY zA<^OoI!k`4ijv$P_z>3`q*x%c-woGbg6nC2lSeK?cjZdP$;`tyG~-Ducd%@8#D%l@@^$2c{+fPJn_yg#PY zsKt9C?LL=)OE#z7+0hULLF6G9v2@UrE*Z{>2FxW1P#)sTh zc;(1E-06a$%KF20<;x^XhPj1UzEv+Z$sb2F)@|Hm%+o;&k~G4-+1qipV0Xrw54$x2 zpNZ)AzsSx*H!Bt0_EHkvYQVnz*F@>-BtYwc_vmbxT*gnNRZGs}h@w9hS}efoNa=W( zo;PJnzxADfDSiKWZrCfFKfr2(R$|axdHPz`XW~PZ_5ayw(er&i`=`_8ClMi>siP&q z@r7*u_M}Rw3K{x33U|-yTD2ISPYXY#U9Rsu$UJ-8yaXFp9>&`KnNE^oOej2~li)tYC{QO0Rtl|+OPXtP)A@I}P zjNIPa#UBqSBL3=7hea|rhB3q7N>%)4#M8Dz+LVVFAr$Vu|>!=2&#FlYkbqgO>0 zrdF4hvzWcV`4uHa<$_-Lr>;fjTaAHFvPr+CBmrj#Q0>6gFKOpAv#Q2vQnz3DM(5^d z>`hpz6jKJ`2lid#(9v+x6C_Zr29FIGiUo?ZPLK23Z{#EF(L7#bq@_;wyx)UB&!=he zCze=w6uyQL!{|+CbWl2mapP`HU()j@227H&HftJEX*UDvbHTA}^|4u~pve zy~?Hb@7{|7_e2sj?m*ugfFFJE`*du{o_R4H8l^_j{Gl?QrMG9RYM9GsE%oWZR4N@q zbp~=^)CQa!={)D{&|1Npv%DVcu*8^>DRx^A!}ii#WgKNagO=8Z&k;%_Kn^e!o)xq< z^dL?3lR0xr*~~R@Q6DSDkdtv~5|3{kcdlEpSmVxM7ZZ*EPzaK!XOC$?6cQ}62|UaD zVD-%DUG2&>mr12V>wE_aBk2lEu1xmS{a<-mKu!#_zC%`Qa3A@-nc_Zvp`K;W9F|~L zM$H1-D%;4wOCoxqb2s{U{skY413BPyzzO`CIpp{5cDOL5#eEs9e7WHG#$1dznN(Wz z&CveWQc-`7-79xMaTZ8|1JiSQe%tYoo`Hu!ZOFKOXEzWne{repP!}U+TI{mrEcSc7 z*~g?>^`;3wfE<`f4UgFT>4S7uu7u|1I&sr)_~w2Xu&44&{;Kq8y*^1-e7`7|1Fs^R z12}I2WCw9j@(p|^#%h~0lZ#~BpQoQZ0Q>3pA*UANdR{aytZ$NH@~KK7iq8iK8DQF* zr1Q>I%|}{%jo$+k#$-Gy!>`;~xjLpAIE$giH6Xc+u^C!*2RKt8sR)Co!Se|>$?C6a zslSLPwXP=Em)1us`m_$c57!JodH!25c;#;_0A2i&Tu#78ju5BgYY_CMv?n(Ydx{CgzIzNi~oWi4ml8dSC_#`~8>C<0_uUQ@;9jd*B&xbI@3qPL563~!WyKv=fwq}eWo$887Bqf{0RsWwpS@CK zl5m<#?V1@nffv{Q1lkeim7oTBTT>IWCt$#lihn7MRtO;E0|N^oY~OZHU(-)H7hmQ2 zDd*~-)-2;hQhf=FfVoEUt3n1lv19=^MSb8)fO$G_c+o!s`SaNBvuAJ6RGY+^bKj(2 z;EY+7vG!p<_(vK}QR`P==Z%So(SgPR$UH=?AZ3Ws^;O1%DuuT>m^hW7jK@l|E7 zm#I5F{;blMSn2_A4oGDJ0-Muo@cS6~^K@TInWenS7v>2lvHpd2#e_+0Cs13S|I(wJ zUjrpGqJVo-9E@;<9|E)+2KuBW$qqWG&(a$rq&b-V(`$}1 ziZW@+?78+F-{ml;rfkqJ^#w7D`|z$3T?RFO>}M3ME}qCAM#t-&!7r3%PIc3)p(Q{q z=7WCLl3A50w~|raZQ<)Ypgu;58~8eq*$Ze#%0*jtsO#OSC{$t(>#sq{9~jaglfLi% zfd13(M{^hNZ4v@GPzwnMzny!L*Qa7pkShW0u%fJx&|^Pb*!<_q;~w;C#nybaftlQ- zf5ku!urI?0*9JFqgM(9^9f`d_jra5TzEfG|jP2*?~Qv=#P_Zy#3Bube$FN z%eN5=HC!U2m?QftbqlWfr;Uw)0i;d-Yh%+F03|LKNM690)HfX$Y6GF?BtS*EiNZ;b ziCK+9gDQ@KqWc*o4uu$<1|1zm)bSK0L5|A*88SlX8@Tnv^?i&<3-b~0FNk3N1$1dn}lAK@@lv*;uMZL0#J9lQYanqe~y}lSIUHDPQW5VV>B@DQ5yJW zVd$h!%C~TXU1GA5fWGp}L*Pq-nu)W{t?#`^gMr?LcYz?|$le5#wc>dB80X^2N4}I9 zIjmr+HDerB!7(5QN+IFkO-d15z~*s=JpcFKPgkCH8rDBbYYS20L?xqm`iC;GmSh*@ z4tJ*{)7bFyq~AxZBz2$9?(}9+%TpB*;wop$-x%7v*A>1ojL*rXtj+vn9;ohiT5kf# z60~x`8M+#n&>QS=t{{20L45zGBH7<)A58IR{omJ7|I-wr^DAOGXe%B7^$;Lm1Ss@R zP1a;T(#_vvK1?M(6h4&R%PzBA#FpP)78vPG{W0*<(DqJMjVTEKffx-pOvKwZi@a(D z2F%|CZt#Az*xhQG* zHQalgJGrd=>8YFz&J(3BCcD^h7QFYDUmyzYfUgd7R`j<+Cj;b4bYh>XuxZZH_;;3h zZJ9~2i=^TuC3$~z&%JUg^)plr>)f zk_CjiaC&8{8@bMZEnlWhLa=(>dRMEtx+K%AMRX|+I}K4jZ%k&eOACzxIdRaL426l) zGmz^vPpy~!Mx4wvC>AXIU?PK&T)nsp?JJX*l+WR#;Fzv(AO}cG;k3-qc{n?*HH=;d zoBOf<^@){$YsUOM<~>_#Es6?O4CqBk>AB>HI|*KX=zE@H_-BdrnHr+cT8kN*7A*a) z4W=8DmBUna+@;Zh_w9^L9*>FO5n+O=6zJuMId3w^*!AG**?;A5VnVfi>Y>W1~25U5JW=8*z}g`pSR ztre-Aw`4_eUR`H=-4)X$6V|rHr=zZymseOzsh?sff1S`9Bw0W@{;W~2dlz}?spUiU zEaOwNf10~4JL-wel%~f-JRi%G@2`CBNa&SW84@5a(uji;q7!kivy7lk5InL2b1kS^Y&EtO45^$ z39RjnSXNJt=B|{g%`xDSegX}?0%V61$YMMu>#H;b-wk6AY7%E}EN)dpx}6iB%a9U<2+rKOnn+Qy9ZPkhqK4L9O)<$xWiV4`xDN zu8MPyayia@uA+STebA#hwk{5wHor6{P|VY1PMwdzdx17d<`g4(MRPbF=U4hKEls!P zdwXfjJz68rNC|Grd`5T$pvw=sb=~J)?$|!vi^h&jlv@(Kz3eWOta2}Zl&&=OMfTKo$wvzQ*$&5BA|8ha6j@FL70>Z%f1**z{D3$YTPi3Fn8etcDkK69IJ3 z2~v%aZ8(AXW`I`Saho4h`b}ewGj~I03#Y?5wrrwrFCYtY6^9vnKLL0dmq{Kp?cv5*Yu2oQ zK`+B{g9n$rKmd2)Y0ZTGcnGQ_#=mzfk~mixu9+e5FYuP&^E;>3_e>0A_q>)&t}S-E zFoqusqr%x|gWA2R$o|0peRP^2Cy)~dz!cig=+8(sJ9K4QQu*}nvz>XxC&A7u$x#Y} zM{{aF3>xliMzK9s1x~?jQmxr&KO+jphEXu$n*c&wtH8aQz$(4$%{K%pA8KoEfMe% zyg|^ug#1A^*1Z^&9(p3r$PElX zl+-AGpI)!nJ3$^ZU!F<-YAa@2=E*Nc5JyMMQ-Cg?>v_>sZC?ME%{Slu6qJX5i=eSl zld5d@m87OIVQ0ELkI}K>w_5=vckzN$D76rxsMXIPIDv>PeOHol2 zl+;tG26aUrmCo-Hx3f1?cACh|1s}4!najWDWjfZw#$b$#4&6Xzj~Z#5x`SLh$v6yPO-k&kC?TL@sGL=4CS*F?wko2CKY*5w6r=1hHM%}kU!R(nqJ1(e zj;ObpO!BmM=}_;eLfkL@v*PwYRe0D`pyY&v9obLuA9#BDb0PNaWAEdNhWi1p$5*7@ z-FPW^*_pn`xo3S`^sS>wvrdfCt5ZY-ZdPwiPO@flb$Bwgx{6HZ0DJ zFB=WR^jZLE05V@5=xxj$L0U`W*4INSfo`Zg52~`(jjz)i&i2q1w53i&2@a{9+@PaF zoEI1Y25E8mJe+3%r}h8-^WT0UC`Nspu^wznQvW>_Yb??IL&qo?hBCQ^{~w#4H}5WX zmnRmTLAsVlHx!sEjOtVZx$iy~h)eir`HNIVjAR%t4Zu1zmga z!;P`FtMm?y``66v>6MJARAjpLiP7I$wQ7-kOFj?H}|gkscCZ@~Zi zH=sg3&Bkf3z)8>X74ISM*z^H5;=TS8{eSO73WW3;a|9Khqka2@ z`4m)(f#UfpP;`)6u31*?4Ka9&5gmK5XK)^K4v@CI6O2`|rdj9e{g3@bfb$ZLW`WEe zsz7!@zIycvsCbr;0s~f{^LDAggGSJZ{^u7Xw&1Ke0(RpXPJ0ecP##wNQF$^S)#v>F zpO?o9O&`~ug^=)l<@%`^T)jGIk{{UlEWW90ak&1tRR+JJKV9lL9({a&mAZYDCz&15C|=r)}jq zB2C~o+lrNy*wy#foKpoO%w^*?P+c5CYyNf(*EY1zn3ctXs{t~XFri666;iWY=VCr$ z$E7a|cpcl`+Nu@84iM7WZAmHRh^q^s;LHO@!zB)?jvzzO3x)&1fgckJIx<#CrE1>^R(CvtTBS|53O=!Qw@R;$~l_bPqOR6f|g(ZRZctz5I783W|R z`2Zuy>6KdZLhc7i#|RT%(%_Ny;)0D@xwZCtg$Lc%_gOa|)bIGmP!za_ z!@>*R9vA%g=CBTG=4pg9 zpQ|W^-(5qyBSH<+x3{ilt+0>%o|KArX8?N1i--w8S25;%PB4vxVw;PV{BkY!aL-$l zsO0kBS9*Tl;XQUoiT+_aQjH4az*u+K^wzZ?_0p8Wp+bZuOugk=%4P(_cY`>6?Px*iM#xccCxVyGitz?5RJGu`b&_Y{X&56 z!%WGO2p}g7RtoKBZW2;2D_M3K*9Y1x*3Ggs-{~Z3vyP?&8I$q!Ehn@)6XIb%2l$$q`y;cMtPo&Erj1L1PG#w26_`TH``F}xl(V6?i= zF1^~gfuWgULN+t?3*(zQi}B6yXT|;i_=EY^Fd}mU{t0}~BbPtidFEM*f^L9K8{zTt zw@ie+>*5N(tfx)Y)vGoSfnFnkKMde&;pT4e`xZZZ*zM{3yf7s+Ro>JxjDzy(CF&?G zA9vWEnO1JVk0T%lB5p8IQsV@4en9TPN#*z=t+92>u%p#R2BEI&^52JpoIAgMPi&9l zWZeL6GZ=-;3)jXuf$4v6xDD5kV9j<(k*c@p(T_OOx6~`CR#Y`=Hwjf+KF_aLxC#JZ z0?6gz-?#7=`Mqz&OPII@D(cz)d=_GUJ)PIlk811Vw{R?VAk|bkoh%|I4z?3IhaU+@ zJsWy<{BVzlU9>pwY+LJfkgyKk*lxr-&hlLktJ;9B3wFyuMx$#&?h#ToQJ*fOKJ zG~D!+{GRf=CdCF`P9OXj^=2ntgu?*J7a;x2YD3Q3#@%bqrqxp(lld4#ORAX{Vk=d5 zdu!j*FNEBN!7oM@6%28c;)7q_nNg%#bMS2yh3X0uW$MIP;@Sj!;y!4Xn+-JCdDhjzRv5hwrbQzCib&lH$zGO^#&7}J-b;e@pr2YOc3F3DL{4rnI&h~uK@s9)2%La zekSwQ)#DwR)#2tzVWsY)ZHp&{hgfXFuUQtE0V3oCmCMj}<|W{sJtsxGJHykjXNXzK zuf6rcPH<=Y{;hB8*Um;!9La+n4xCC5Hs>R2Zl*YkCWzm}w%Nt>dsRR*%YlzwE+1f` zW#M3?{HQfBGG+YnAJCE}4boJQc5T+cz!Tk7lpf`REQmfcVPcY@pjYe0wc#qGpv8lKV^L^`aXoh_+ZNq?#T5IQ3 z0wQvbG1gZ*&kItr^}}izZh`$p%wdN7+p>N>C0xv3GX)A+#t|bcFQ6)w{np}I| zbTt4sfFumgW!4_SB;==2e-tP?0rlGdi<)Q>k`}>m{#;Gr?>PG4(oG`u(UqG8sEork z-#zH-&vx14F~0!*R_B2qW!pDd^r9x~m`~M2;}7PIi6UV8#j?|29=Zz@MEDN5AKGm}?Hsl#v%d%cIwurV*Ji^Mlp;8I^4{n_>^6!206cTc5C z?zz1FBRnzC`)mC6TT|T!HSd?nOV>L!!S=HAvcni8pdOjCTGvmXR(dH>`a7X;RD6K7OUKH#N_f0V-Qr*FvqLO*Os+m^b-2&un`qXuN|V zi_+`2rkZ=kj2DeQN;9&Ly!4P`{KMDt?r#>U8fAT*7-&~UG*Q6pO!I3yN zCOG|)=Z_HOQ%9Q4MQJ`C-AfX(&wv~sK;n>hTYk>fCgZTH*lvAy7e7IO@r&s<{#B3u zAeO$iN(cVele6_$f=Vt07!_8q5|3t z56aD}+n~Iji|izw>P-DDM)LDxM!QHCi8^~LUTJaFPd0b4hQ9J+_3&Dl(IEj$r2OJ! z2W^yR`-eYXA#!UYsK|(|a-&yt$`5_(avs6(5N(ISx>fvLfBWNm?5=l8VeAp!NMNh+#>vgP#YzX+g0_D-E(C4T=T9kG)XlP<^SD>SoBTsX~aampy8c@GX8t zHxJ|x>Ik_OPP@o*WIfCcJOfeT>iOHK1Pdd~%%o=YVZIae#vw27I~h+Xa}!;bK(tuG z4bk&3m;wvssx(oYBfOtqjaiz=lD__4Nwk&#>n;VqabT+xA9wq20K!0fIc)C&+mUvX zQ8epeYV3~r@r_3GY)-~^7l*YRh}@!$8rMHyGN!qL4V6T&07Cbz^Zc==`lrD$68C|2 zh&GSwul=pjVM_UOW>30%9d;LRDK3#og2!F}pf~6OB*CdJu+A4d2Uk7kDJSygBkmny z+?^#A7rEb=G|<=hkogXqBASM|*$AP15k@P>}IBA<2bgmv$v#m%ac#>6d?hSF}a+VZkituEyP`h(b| z0YIt`S~@`#5JFWutuU$*LkAB#8Olup6ii3Jp^1qah2q?WiU3sT*dRs(5f}YAjfef8 z#SyTjp;s){d-l?uhhL@h)58vt*;@MCE^=|FRRvx5xxf7#k>KIv2Ymw24Nluag8A3x zal~JrP-r9#>u*G$6Ik?Y4VM?hGUfV3eT^xp@hk;5j2#3~;Y@2jvJ*VpTKJwsX>)dz zu-1^2Skc7aBivtQnZ#{V`wDRuGT>bbQ z$8DM*PxCF11LY}j%y#7bvEhpiW&g;R{`*@ua{~E5cvF$cAlYH!uUZdj)cl^`6J9`0 zfDaUuoqq4jIlDr#k(=0k8eb{z6D~zGR)ZF9Hk{#j_c15F(WXG3+n0O*C;@!tuoVhE zcXY?Ut=auX+pyyds}}F&_2hEqNoJ>08g}rgjYY*YqXcz!h#|tT6`u=(tQS!JE6gYK z7QCoEA&Ox;^w*rtpXshE4Z6J|WaB5FxSyMH4}md3Cg<+%>`kvU2#r1*I$Ohlh z{Df)qwQi)2WMtgIq&*hLB{q(a;L%466oT2hW>%4MED>SFyDN+-55;4hvgI>q3B5<( zRL|?2-0a{Vp8Od#2ITkvT^4jnSKzr};G8!i_XL#+oNQ$|*`>N{Z!2>cu&F$r?lTz5 za*Sa2!Um2fnD@pG2Pzixkq+d8Y&Dd=?4INa=FVp*%jHK@o{xB6p)b8#-p}HX5ghLV zBrk_Z|x_oMpjHp3KDI$xXR;Y7rn55%Bt zS*%3bgf!*ogcC#Wonq{#WjwSH-cJx1+z7RclxG^I1F66{Go+HeBc#V*GpB&C-k8FQ;e*-1X=z`tTQU}HQ^6e_T^E5Bb_%W@(=HY z8g67TUT+qw_|VyP0KOvuYEGd2I7~tQuAb=^+rDoq@tiIRJPb#{S7(c*3i2LjyJ^26 zb?|gB0>m%*#Sw|+Q*{o{MwZjZd#-aj$)g&)K5_HN+@z}$UGi}(*N|4!+azKAh~f;= z-vS6M3O$a0n~-YBeAOKP$KCZo;ZOQgwQ4^T4Kz1O#TeLdmC!VuDDL37135r309x*m2I>oZ!+uPX;u8f1y$7-IO8g@QG8)I>5;xb4!r&Fb#+ceV&B0ye$D0Y z|0sk7Cd$%cpJj+RP8n@D=(n!e_XoBSae=rLcv0Emvg^;lq;W%;sK&K8&Z|m3I0n7< zLx$znP!irxR(2Iu5QT-g6gTT~4H01q0D@!)QEnoMG)Z1Xhx&h;zwGkJM3ZiT%9p9U z=iblm;j*|BN={{FN(KNK00jqJWtXsxM3h2zOx}-mm~>1tttPy=hkIm-HUAXtL-OH+ zzWW%9IRUGn_!Bs2kiG6(L?T0+cT86*9Wjf?cmoa#r-FwFsgi4QH$K1Nj#c8!tiFbi zKsKPT2|Bz;_|Ab#pf@tlnd2e;snc?owaN6&otrKU1 zsm&%O_D`?`M@%?ST3p4{n#0?s4q06v)fL!OBe%_TeS5dS|H-*2o-$zKNGX$cN zgrz0DlRi!uY%_tNFrvl{R?hJ#|_T&X-*vvaBgBj2X9&RM%dBjejM>sZL1#VwW>a~wljSo`(aycrA+}$Vdgs<9eLb^ zG|gnrdUB)zEOl24dZcujRey(?gue?N&aumRHkOPhz5t#cQ0o95gVSyN4!i&0bJKO9 z1eu*ug%o)Ix^@|hM?s}MjXK1hf~V<43&-wPcdR7CgXb|fQy8dP$gB%22}(N9YzZV}-btQqvc&g_ z7cVSI@GgpmIl3}_LG{A9o4lhyrZ-A?Sp%~@{4toT0Lt*7vphLK>Rc9{xI?{gOE!HU zevLUwIfvBDzUXp)AWdSt#%+TfmSKPk5ZD&NPJTgn*w`QgeWChvfl#t`n)6mx9DV&a zl%ZQRD*&Tu3V~#yKL^HwEL#7g8n$!#jxieKV~*?&sH5& zX4419$v7Qq}rpSCU08 z%WY%&ULz3?jqD7t=}q5zmdWHxyjI~opO{-9IUFM;`o219{BMf(&w`^*^}x#qog%P) zjI|>HoAX~5a>=9Ko#*7SxEHa9RB)K5L);zSIZiw>zM<@076e`@NdWYq<)?sI+tT-bSZIJx9m#!f^s^oRIB;n^ zWLnvKyV&zZVeHT&uLoqr2JJ6h0@kBG$!1^!ECuq*oN&^hI1{N8d+T9(^>h4BEio|e zOKI)ZlC3O!^K0%aN$(r+5&0DbYHdMP02kaC|Kk83`zly6E@Lwn_>U2?D8PI9@ z=Z{D!^MZlBkaeFaKw3>YJdBYTxpLS!?MH^zXyUtnp8K$f7PUOPlJ9JZNDY4z;mHgy}#I4zkicAiM-y zP2nqM`ifF_DX3a^AG_{+ME_EsZiX8;ed(R2-4fZYnOV^1%uDv$k?t&9)2a~on-f=> zM_GW=P-;{ZxBMk#{?sF^(4&x7_oA-6t02MxqqgBt{JJ|b)7PVM_xb}tF8!fP${`rM z%5{Wgq@7o}uKB(1gkx%n^QcuW1xHvu^y#zidh# zXE}B2@4W;*O$(pfONb~U2dLydmHV5A{9b+Ll|PPhrGpdGdKIWc64DcVvk(8Gvo&Ca z``@Cxq0s^4z}C63G-IZ8ZQ09{(n4~JGF|q$JC}i)0GdQFlkaq$ z&Tu(30PN;_ugzl`U8PtS4Cz}ASftS&+QzO22@7mfh82p%O-+N#0BBp!Ca$+5e_zNU zC81vd0RvSwMuK(0b+h5N1p-@AQ^}F|y6?oc8M~(r!Wmd8JkPvU(otUf|D{e@zlBvV~wA*ZDv*WQfuF!SVnz^G) zrUoCv-ZzO}<98?Bi@@arYzlBRHy1AP1HTWitkV8r-7c3?m6Q_4)IflnOW)*7&4kWM z2daIjy6Fgz0}~P9=I121!4H^arWWR0vmy+-Y3%QU(|UC}fuAvkiz;^)6vQ*hgr>QH z;{;x zQrD{GmC9imN}O!?!)>FbPZawWn{m)MBY1ZBL4uGAG7lc>NEVX1?O;+#BJQE&`|r?+ zw6|a58VU+_@q|BaWOV-hM{ccy2vvZe%)J6xSc{Q0Y?1Rz9P4e1hJ?zUYcGYmiY;<^ z;x5!yJ4scxuLCe80En^R2Y4T_Ho!rTH&d>6J<_p16=;#Ncl0J7pIFmf=&C0-dW=(s zy+r*Lk!b~WCa~jr*oNGX+|D6kw+X|@!@jVq94tQ!Maw#@6Dn%f=hxBRE{8jV$`3KX z=L&G70CR zsgoMfKuGbEPxnz}sXapZgH76%3gXkG(M}SK~XPu#a0s6)Dg6nAF%DqpI zq^@fHRNsEAb&+3+SX(sZA@4B8gBXrO8%8knEoxzlM(!JxLcXh%Kn}t_4h=jNLKgd7>a; zV(5aU^H4ktzzd-Nus%*FAcIFJnqKL9U+DsRs+Vh~DkN!hgx=C;cA-&-cv#Z2R6P_0 zpcW*$A@h}9hWuH@IA2%sWwKi@d9RWZ2PiyXe_z0LT=ovNqJ|3l4QCz#F0yljk>jV^ zpMG92@*#Q%Ma$_98ygiTGj0rDo36rivVB}^&c2_MsH@wtIs#^b269L)t`-SDIQ#Q1 z?JZdv&x;Cq?hNU-J>y97elRpCS|{eAYAP3ssO6ME5T2cW?`H*4EpgPWhJRyr|MEYf zyKDE@=CHD5nMc_6!QP`X+(PDl20|bQ0taw6!CD6L_sM`E4~%>3S!Um!iAib8e|2%y zw)suzcQlBv^#g@>t`o?C6ek>Kavg&w^t=_jK;Z0%f`B_$#Q-oSLP2?ifoheIa4`Du*$%v~~N z*VzPAX8WS_sMv9)n-X52f}EcZEB4Z zzlM0(fGR?ks#PX&`A2VD(u5 zKC+Jh;*h@J2sRu1Io;Z}(;~iETe33!{D%R_IQIr`Az&kJ=t7R%OTi-^bjDK=hbYGBAdMu*%R$I6{u?qbd^6jzkc5sjO9XA+qd7?_>(fU5 zNZ%NL=d!oH*4^9)t2+?g!KEHKO_z}46ZHttnq9u zz7&pjoUtXs;^YBbw5M05-5F_F38D+<6r)=6+FV#yr93RHbJ==0<-G)$t8n+y~+_XWT$?q26;BZPI*x66N zmjEYTfMsna_cw|b-R&WmwSg9&Cz3&03t@4N*%wmQ`Cntn86n##W^Rk=Xd zGEg>sU64O=ukUuB41X>nKMIJZ;g|c%2+{;`@HfSpkWWqG4XxBKj|ct`3M1xVk#Kmr z^-Hl{Iq(_?b%PdyvzEX0Wh7$T9&TJsudu=b;S*xXYuX*Vb{DfQu=U&KyH)>xgnf5B z*MIl-$KHj6RI-wW%*@E%A`}`%s3ghG%HE31%sYTA`&{Js&Dee~={5FGUv_FXP0iJezNZZZeb@yA1mqVa z(va7MF#!VPcnlZGckd?=nasFR6XAb+;&##I!!J^snH=i)p91cHfS`>wBG*)diIrab zRT;(D`RoWg!+T{%5or#7j!XW}XnJjm`(mt6AHt0HVyv)@==;3$4in<$p|9+_Ue)^P zjcf~3ZRACT_u51ymq|?G(~G-LFjNZmf(Dg3h<^DX)LFRBvZ}3Ak@t@~F%DO~uI-A*gtV zJSoC#jA_Iuqnni^o_6kM$TwGZ-_6n{)>MZIJr^{IDxS>u_#St>eFB1lGSDs;O`30j z0xINIzSy+qPW+niai+}s@rxf`8Q3C(;?70(A@;*aDqo|8~7a3^8n{ zOl-e)UNSqOWqrVEApH&_MeTL`tH)xohB=8}L=c_={3Iz3$xgJ~&NybB>^CBxnWuZp z)J$J$7u5Vpyx?*7Uk@xtfyS*FZ_dyPZF(C<&SBDKMKDw+X;Sg+n3)fwlBx#If zx4YqYlWM?alkQZ6;hT&W&?-_;5Oa`7IbLO-esO(yEUd$B=R_9bME%{qETt8{&;=;eiJ(h>XCdKW( zw1*ENAcOW>GLlFRuFFrBOW#i{Ty!fZBtO$9rhND4znAB3#iek^3DXjz44$)r9CQmr z&LJZQqowaZ>o-)9x+leD952k<|x< zavR&xceBs9wW6P&70v$>+EkR<%gzLH(0&KOFA2!^;5qCZm90bJzw8lAA9(Ciqlfc@ zys*e1!W!R-n8@k1+f~3lP{9s)=l%PVdRSKbGhnMwIwn0axW>Rj%dZ3Q@k*B6h}* z9hZS5D&hwg9I|H4a;%Rv8jm&|&oXUr85qA_+W$3ol8XDW!OfhljE6T3K~4r75%hcT z-$IIh{7?)^#1t~9AV4m-5->BK0VRQj7vzFMNioEuaL{N59haQ&_rSfS6|$Z~@Sf;e z`~{yUljKe`w>gBU#D={4Ul{8iJg~OQVlzH6CJQB7%Tf_$O$`^qvmJ_mU+-IMlV>)l zrhq8FI4_JrKrdu81Cunl9_|)3TpPF>{KoTjaZK#vB)9qY*S^Y>MQlrEldmL%VWVZB zmJ9vBBD#>cB&-zucNi->_$To1`(O-BMV!32!!go!_k!}Oi0ftxZ_vXRgjdQR2vTzy z=bji3&J!vIuC1J@00?Ye(s ztfWd#;j|T=?57QtQ{?Z~=k-O1FAA+rd@EwOb&{my$_VY=y#(!!R)1}i)r#N2C&Rcj}taCISN}<7l8oQ6$61eMwQ(o8}yvAT3L(8-Wt48^L*9i-5 zZ>Wh@JsQ^?ddY9lqhLdX5(n)j!ObOzNvJKISC4JoPJ?l?0E_S{9i*r?!beS0y z+I0GSZdA+{<1#Jjz1P1-IzexKS`Zm}Ap9Oo$Mhikk8MBLd32xQsh|9|@oiyf>xao;nV9^$Z;du{4=F=)bku{6JzmO|`i>F4Da--yq-?bz!0 zAFSIfyp*yeDr)7k3cFRs=lr`xqp>_L-|b`V97{e$o6v(N4+QOlG*dWIoCy}?OnKX+ zRvAvIUXr`3Jhp%JA79>+?7ns9C)gCzzu6vF06Ab-A-!IDCyx@7LRc858oAXz`!2@x z*01gx7L2$yscet5#X3(1zVT5`?JK{~EAdc3hYH8#V2#GUl}@VOm9?jI?UTed#2T2t z>Ii;(N8M%C^UBz6OcjVllQFW!PxiJ|r~AD@i|1+VCiSl` zJ~?Sfc+3^aTNOjwFDcr|N_6j7IE#?N2xkHEkZs0YzO@NHtcvle3wI~~X}B+~rhZ-C z3RH#P1QbZ5ZXhKR9mN7UZX2O>ANSqlo`sSWx=E2K!WnC`1}{B%CKS#^M=Wyz!0bSZ zLy{SrD;O(sqOW%Pq@L=%x_rfmMcUI-Jg@SeD$FjMx4(2*;|vJD3Ubg^8?kl?NRS)8 zms!~?KR{rvAO9fQ2j5tWs=yjQwphOCSCLS+xcSyI;85~F^DZP<-2qX$J+K0DeOTvx zNWJ?C?C#5LmZ&OUZ=&H@$WqdCCAW?A-xwlgfic(+Ek$2Z{{+nQGU6@DO)Np_4$;U( z_(?@PuRHb4W8hXfd+@ii=I+W^h;aj(LI6?fsR^V9pEHeSFn>qe@{D=-#~h`i!~HYA zk~fLyxoYpd>$s|5c z0rg*5yg4BtCUfAB{71+-_DK6DR{G@e$AOL+Z zAV_K@-Xe0Rd#3BI)y*){Mx`EYtR;v|Fz;dTi~prn;vE3`oO>;e_kUjBVFTqbBjaqg ze9{fc4A%0>7akX?kDVpCwEctQn#=6`D}Vg=ASVTb2hkQL8vIw}@Rr_ce&o%uLRT)*?f0X#pfqs+AMJm>YU@0p!&o! zGJw&*?L~+_uMU$;K`(23l#+U>sVz0RO-+}%`1=Q3)Fj`Kr244lJ-fPY3vv<=X+i(G zHN=~N@5!2mW(EZ%r#;dyI`jPYAWhH$Z`=f)qwBd3Uf7+_Y{6U$N<(*0^g0_4@mt(I zgK_;HUw?H`tmfsxLCyB73;bRNQFufT>%PU$SSI6q4rnn z0YVS+t2d)~)*4cZ)kah4c_9!c&Ij#{(YSUY3!@<-(&@y-tJ>IljK#cFQXn9 z$&FnWM)_iO7Z-v?k^r|CiF*daB}3ejleKmzospM(VNZYkl`s`)iXaeJNYhrl5xcEm zye`Kp0hKAx*8zR%F$ipj?fl%O5;1hUid89{k16pyVT0to;~XXb!sl^XRh&Pv+FI6cr~6P{cntXyqV1+VqpBFpil&P3z-p^W59j# z^nCa`K31WJPR~1hCP}Texa59ZbRwuKyf&p4wE=NcDM&UTZ|~(S#+@;AerMS)-e1rc ze?><7(x;I`&$biZPhLd}#9pi+{<$^_a!~S$^f!rx7!dON7M~6>gz?$P*G}_ZsmWMc z+oYLzH=29|d*|Y05C!wg41h;m;8dd1Xl;khus5h@9(gnMFma3IhH4oSNd00COe3+o zS!+YiRIzjSIW@>ZG#RqQ!)zmn~@F?!> zxPTm=-~mzStv^O5?acLeX&QJ=oVjci-Tmzib>$t8p^=FAiFiiGfUQR@>mbJu9C`F} zC?3FEGwM&1=bNMSw6Lc8>XU7s_PVvsm%JJOr_6ar?n~L++TJ?F1r7$Id`8kf00O2+ zxNVDWXA(?2uW3E?#pErX@j1gD4b<1`3Wl#W&x`_J02(_S1XltkF~4t0f&Ig|BXJ|j z6{t%;R33{|if*WtOD#Qd%TO$jjEmR?IiLz5-gYDG3u4giGM5T!i~MoZ zZ{!r*h^!LY+&U*&%FAgL9C?gK8Y+lq^&6XZ;bL=V49f#<##NU(`x7Im7Pcq>igfalg8o^+VeMR9@iP;AM ziyC*KOwIPoQ!;AJA7?DIPnZN=A9^x6Ouod=P~iTB5}QYow$+2-VBg#vDsyR0w9c-+ z&f8?0>Snv1=kw^xP{^64`>I?EsGDzL`hpN}&9`dl@Nc5~-{z&`LwK>itRTz`#V9)R>>S4@Y^k+yeglvZ=tMM05|ul~Cz$EtHq zXNw50>h-5R@BsXJw47HxM$WNh3j5lEBMI^{Jgc9$%`$N{4*i z6$!}DqW$ZJml(Nk1#^T`3&8~nS7sKjWb_feBJ{bv5N#*YMMWtu-meLH)+>@QhZe19 zs}5VRcrT?S)SYp7I4re%N5?WmKJWV5QBBTwPu7&A&$lSegMSAjN#Kd^?|WPU#xF0p zL#p&zh44mNRM4+=pQJ}2SDGK5%X}2P{j~aS&TV=Krvd8(dVlWAjh18VmQ-eXV%QO$ zLF#HYUDm5dQV8oUUa!;FX}5N~`yo|3dmEyRT-=;U;^z&*c87aKOD-}MfBCEZwH{-U zvor#Am*;8v)H&}aiFvi8&$S3Og4`Y=M%%m8R*Yg7)iiMSWm@K%NMJ4UAC`R9c)QfC z*0PPwXZFqXMC}SQ$bnOVoS$1hCjLX7cRqk+B)Ht8W{6lj-Ebj@IM4PezB>1#W8IqB z+(+PD!iehwzE&GFU`6a?++Wq1a~3wwuLR9j4vgrV&YxJcne0w5FBR+T)lfP65MYiZ zKhh6%5Qe27Vz=$%YSpf&l~cP>u4&WDe$0RKbS^lDwyl8CHs71@dF9?XoP$PrabGd& znQ~70Nlc2%>}u^3oWGo}Bbn&Shb|ajQ4bjwPt%a2LjhWW(aK0$&8fq>Wc_1B8;+em z*f}>Z4613*F5%2l_?uf5e$nVVt^Su)PYuumc!)?$IdK8=x+!Dd`-KIiaApa9C>&}g z)t?Nr*`;aHn+*B5!ER)I&U6p0fb~J6s$it(22O8dgdSYeF7l)a~);z6d!{ zQSunbNdxNu{k@(;x^}~dO6a@b3_O?n7y!`b=hd0Ef<;robD>)&`2$h5f z#VsI*XjS#T2=m>>%IWhaRRL+CS6}$~lK45r66lTVq|=iO^a(-3NbyoY69ic>| z6*f`(*q(PlOL6_I_n_~wFuP77fDK@c5i-&;60L>(AWJ@zz0Bn${n4CgXZhy!W8VJm zk0bxu{PCb5`-p_##4c>C!a)u9Kui}y>$ zg9_hQC3k^2hC#4Mv@Z@R2Y~O*3HpK* zd$0jYH_+N4#}&iV_PuiN=8ujWpY-oG+Vcs1zPu3t$Lx%k^d?X^1!>bW zF6yomA*ocsw?!F<+dx|hdR;xcA{u^Hd>$iIUMp1z9R{#JG8dU0$&6{!MgpE zPqQNLPW`cb+w|~@T;nD2g%kz{{7nZreS>)A=fof-i{^XpB6&{I zy>PB5wlc5xb(AAm;TKJgH2#qn4_XhRicqe$zmEZjH86jL@={OZtA95SRO%cxi>3VJ z5i2a|t@X|*q)1lFVjglGGLkT52yLad7Li&OS`@b&6H0Q>+P9UBb-b)0~!!B`$N5NSW`9IImMqF!ZIj_svwE61ud z+i_2EZlh7h=Mqsut}fS`rc96nHwD3~JBYghxa?2WaUyPk{CXj6-cz>mr<&+Wv1&XD z{vO+ACwQ35*#Jo|E}$7A!I`fJ8~`~pNAJ|9-(VcO*>t+^_2PxsU#N?$`&lNv&if0` z()|Dh1;Z?1pxgdNFCz2|kmJmf-QYOWf8qw#w=>=2H^k?2<-C3Z!eRF31L-v~k~ojVZ&?A1;0E^wZ9dD= zF^Y{l`*iYb`~zhJGP+yl=C)=6PZR_;G7IV*C3D@`WLe5U4k*3Gse+Z z&92TS$8!+B%{-37^5nMChTHk$AP4alNE4-?siepdKxT~ z{NmUb&f20vba|9;f^)zIo;ZxPFrVGLKkOapcezT3m$|40es++cL+<0g3umCPe z(*7943`@GT8$!rN=?1RuwotAjL755APAUig)8>CM&Vb~T&&0oNV=r;xsasjh+uSA4P)W8QCl*|E5w z&y!nQ{~EFpfdp&C&1O2SaPsmX{*Zeh28K*=IR=JH1wjT zePC=gJiK4`n{hG~WkRr|-sCZmgSm#ty&Q+g6=EQ`BNNY4N>B%dZ1}#v^~a70s%-8y znz{LGG3ssw_N)G;#J(apUXE|Ryan$|zXmYC7z7<#-z@nG{|-$g^WF_+GZM$C}yhxQ)_7jpct zGfL9&8SnW#mFMpQ3OiDz9WTD&AX7Xxft`AZ`rQ3xgF%QVK&8b2nW4Z7qv@aALZ#N1 zbhk-&P;ASV#QXP(KC~%!Y`!&CJaug&*ycQxt8&pUR$?qBuEtqy_o4SKAC>Ome5rN~ zV)|;JHER2fY%{83Ma3qC3~&`cB)!@#TQJJea+}!%V_`SnCRHWVkMae^~`*yVq&d~?>{`r zbe#j_Ad-OaM>F4HF35*}ME7v}h-J(O7QUVodVyEzcch1_N%=a#a{6^1w@3&;Kr6(9 zFjvba=6e$k>g5PM1R9T2Q@7q7vyWTH8 z=&)N^TydW`9eY@ zQ;Za{638DBe)&43$K;O`&fi*)gZf`YA(RDTzQCIGG5Vimibpd4cok&pXw!vHKO7S_ z0)PdPX{45CXajRyZcQ!6?-Y5SG0?t!RHW6jIO7xkc5qx!@}qZO-Gc|!;z3RlfD$^a zmT_p{tMz^sRd`@gU&@jTz@9$kcl+q@20us;p z?X_N`c+!qvheDcvJgLA@vzD%^m)n|Y?(ALWAe(6j<4Hpp4`mO2W&4 zG#2lr=3@#{gLS6|mlpZ$94e~oayhL3d zSoMT13^+(4<=1|)X9o4_w#%*BObcQqZ)_)Jg3z70W8)=QUpQX#^Zxr;Zh!E*XO}m~ zBkYN1%!u2rmlUmY5U1=gw7q9Z@!!4vGqQxTe9!)YBZ0oQ|E4k7P2bZ+W>cK)VQ<)u zJ+o`sRxvS^%*0Z%$7P-`523VFNg@UJ{xAj~32r=a*I3Tg#Zl3cs|Q_*6Vg60Lr^`Ho1f6Y@z_ez3i9xKoFJ-$#?Mqc9*J9Kl6g*e4Q z<;?Df2c~6{;m>f7? zwzT*$PqGhDwoVBZi6=;D7dTUDozmCowob>~9iEpw0va0>HWUr*A64ohjnB`#^U;z= zuei^YU@vQxT1$mi^WOrOn=LM`TeFK9MBu9cPlpqU_(%C*))}kredcl4^gpex!HJ@m z+?OkGmI#f*J+_>;nfR4uz5~O63z#JcrguGTKr!NhWib6U$XZ8zZfw@hG64J6fMOX= zf5s*iGtG0w_mC;zhR(wXAFt&Q64O3=#bOW{sKt~nltBGNUXOWKIhr86=m90!JvsRt zrEs|Vki|ln5P3*?2(GXr$#~hPyVy@dO8M&0JzNxqPJ8~{dV-F%h%VIPn&POsR zaPFZKci&c5-fv0GBptLeX&^O=ENB$t=15nJI_vYvjA{@pJ3u6)8|5 zSQM;dQ7iC}vUiPdlNY3g33;cvMM|x-#W6yq2c!uAB<-JHHWIoAIpQDh`*_D*MSXl9 z^fMoqG}}bAuV4GoLMh?dx~2LvUf?4EjRo5O?aRGI7$P9I9g+M-WBis<)OEWWhu?zE zx9gY6SMMh-%MxtmZSwqef=JC?au0o9YM~MWfn>j|=KS0PuB~XiSxX`uj}DWRrr-Ep zLeqkKn?K|ZNkSO#-1up8{$db_czs+WcVU#z*{{KwC;WI?aGb-YNSP~msvW09$BLd^{nJ6Z*T_SVwxtN; z)8ZA{@!}*U;E&JrF>0;Zv2l1TpAep6R(U-Gqa8mL7{GUc0)a4kD!VZ%?*1#!jp_ay z59e!csmXidD0Fn0m^$M;q`|+I#8Mv3v;s;3#)%>M`#C=h^0=fs6AJxrJKBntI((9& zs)S>;os`cHQ-5SjX1&JNrVMfdP-}rUU2#x2gg|fMh3C-}yMg~g6FYbXhOixM^=~pO z)!Wfxvu(78E;9jx2r^~7NO|XB9C~);ghsgCXP;xqMljR7 z{MjYaq3~X$r1{bpyVI>M&S9LtKu!kcqoS8NmxB3u{t4Z&XHF5+`Na=D=($*9_>y+m z2k)MG%l%r4d!rX*w*awl!bCLm^X{L-9ACO=O5iYE-~$VbTPnPkj=A=tauL`~M_)`S z4jYy|Qrrtc?e%{_Bb}rz%r%R_y=^+zmiD)v{cmwHi=;ClOW4L4=Ck%S99O7Rs<1EZ zAuFi2K!0y(33JUBBRQ1tOX}LfN{t89Ml5e7Pi1L(9?7~SpW~!-VunEv5Yk@PEVM^I za#%$?Scw(uekAFa&?UMG>^1EPn?~G?VEmdG7TjYFdO+Srhyt^c8DLb2mmQD1x1<1hwAS7WK)r>I*@o|13^(^nR-4oiL z^v`>Ld3|dxIBk7+BuK!2XO^iDLY&f4(0&*l5che7`QG*^teA<+5lLB``MpNaIN1=aXCZXXtG@8%R>Qk#Z6=#X3B{@rh8lg5BFdpI=hq4j5ZUwjhUWBNigN~TZwJM+ zvEBUUCtb9gFW7zG0rB}WmND@%Qjs|2S*++?w0sDp+poth7nC!2#7!9JTEMK+jR=8fO`h|C# z(d<{NYVAz}Gs$oETC-8U+M?)+Oi%>tmj2PQEqSF)5j_feIGyQD#2&TjRLk$>iU&6Y zy_*4$K!o<7zQ1P}b3$fqe*EYWv-jA&O&N844K0F7v!tr`^?x zS#Y@CS#jM%O^R;<`}yVL$IZhMC-^N$J;BUE$P|gtWV}OrDsWnIPpW2L-W|?M5B?oF zTE##Tsr2cjP_TYsp$PO*8;kCufB^i zOSpEqNoOjX3h)Rtrajp8ubY_b!c0LNr!SY&@tml-vh$_&KRT(lJGboVTqzxP-x^fh z2A2-t&q1cD>NAF){_wsqZ`L&#Dl=OpuQtlI7XE2zF7lS!zsYUBte!dl`wQSn7+iwb zw}5c;_u!N>PA)~4J{k{ivkw;TBwzhgBlLs*FVzrkAbY}~uu~h@Z|K+yvo`imc{~ZD zSf! zGA;l60{+5fzD}{8551!^AMkTMUOqH-Rd_c84<1Nn2SWy6I04ejBRy2QwMKH=O^@UT zPUc^BS)yT6eR(tX#Lk}@C;8|J_$Ubhy`t5B3FKQ5NB32P^nIp|qm>qs=R|G3ithIH z)y1D4jH<(W-6r~>_XPQ#dV%_1v|9B(bdZ&9W6{*%Q5frbGLbx1mcE+5(_Vm@8bGN;uC;%Igvna&qvJe z%h=j}`!@UNh-BM?OSMmHrv)Z91UCfS)8;Ol{gx$I65NY_f%-|3_%o2{x6oMQTB zJ(Lo2|D2TPWZdkIP+eM)p8o*P5WF!2t!?{Y0-o-16YX2F{I2#K-mROWTW2`WjD6Vh zKc6~kmf?^yI(cI6`NG^LG`cSPhPlnw_}`WEOop2**(1|PH=SMx)IGU);q;K)-9&7; zko*Y<90QAr3-SH}Dlu~5>zArNaZJy;)AnfwYTh>zrzB$>o8r44U2=)MT=-)l$VmWt zLVqu@1oQi5S6`I0W0?#pS?+GV7|tV^Sw7}Zm!Upz)@Thk`Dd3r$UzHJg!Y^X?edWO z_4?J=PC(gfy3o>iJo*h4a8|wK7l_FP8&w*}*T|qKjVN00rl`o^zu9i6e zJdQn1biv=0=o#hn_cS;3)Xfsys|g2KCqWLzAR-yAs6)6mX%~8X@zzl(tikb^o7bN- z-{HRLbDLv>ZR5-0+~PYX@czVMh!R2=^8JE&2TojLpKMksa0J%+ep1mkM1%>PXdnr@ zmy@7mF3`b}{s!a(L6@WNi}w)bzC>9s73haE?#?S)+&zA0@j}C*maKTYIjfUHk}}@Q zH~D)g7Tyoq1{Aqqcn(bMYUOs((w*!&&xignzF<6)fD$!WurXui9rO8Aaf^WxTU?5E zaRJj7(3+=B_rVdy1<#_CCTSVF*et7Jzqpm(HsbvB*KIs}0R})^@L({RTM6d8)z+h5 zqh5GsHoqab{W|PO-@7|JF$%t=k4I-V%Ph>d!E2Gc0{uSG#x?H{{`mFY)S1K+IPV*n zo%i&`rOA_pZ~2X0)t@Ga3(`tliS_|GN&bTj_G$bOzmPJx&PYc|D0Pr8T=u|#LjP!!Ir^u#naft!A1EEEt@2Kat5~35NsZYe<@N{& zfB=jXWbcsM{HqWHvPJcL&z^|s*nHm|JTU#JO!}+TNrkE6c&zQjn7b=q69@p@f#;3z zcr(h;uN8h>$huBFPa(DrOQd{4$E8=2ILRHNCO)5ptthv916G!8Ku!|a73f>i6-A7c3X}Cxk>Y0Jl_8RR3x9!+$;G$X1SB-M}BgD)JulE}3CT zFtfeA_)}d(<#QGF0c6Rtx$)BMni6Y|{t9j_`KXcj0-M`I2PutNx-Y)5TZ4Xk&jXwU zG&=pghJKFl14@C|J@Nx9w)53*Ns9#9HJwLQCcNO zTm8ND14rtA{OvCsU4Jl}Bxt^HNkxcs0Q(JLySxbDh0%DsAv5Lnk9qtamGWq&HY}iV z?z0!k1_43yLXyM@+Mw?&6{M7-1gAJI?i{$GFltItMbmJfA5 zCAoryxrvmP-v1#~Sm$XvO|;hF$kf?t!Kt>Id9dxMr)?Hae&4O*rKMlwtQdBl{Hb?3 zVDT0HPS~R93!51@f5`nnqHlloOGs~8_|-&Sat*z#>BgD<4V14gj~=acBBAFsp~)M% zUtp7Xjob|6AozkfbuSN@&SN2;AK6HMZ^iXn$IHp#Pd$3Avh79$^;?3@Ox$6PWfExW z0m(u1=MwucA(Xg_oC-K^XU{xI8Y0o?XPHwtcdNzeLz&F?SS%5;EfxVFhe^_wgkg;A zHDT17W7|=LFZs-O2a7M)2OVv?(8;ltE;w^j@3AG{Wq>Ms)!XRrlpt-@;AaJ5U0WmB z{`}+E^wZ4rxRlctExbo4cJCze_+Uk((c0E&3J)A$)O=3%c16%5m*w1Dp7h z;F^0O4yF;@5|V5#xkpMuH#P^z=(Z{n|MHcQku896CYkY$I-n`GMd|VruDKG zn>y2myi732L8Ua(T5}W`X8`LgpwRB{CU_9=u{U;xnV>y?3fHRqs5Mz$_NNb;@q&fv zdr@te?}J|F0&-aaTX)6hFOC&ODiw8h^Dyf2pB9>^jI^ze8~jNUZ!n=FO#;b2D78h% zVikvN`@Jb8l;ddRFJ_08x#gYH7X5uY*HHg%MA6bavmDZr_$82oWDMfN`yE~{RtG)2 zsTs}OOUi3n4UPA{G`5(@MsCXrvl>wG5!qCP0ce57?+6RPJq7cqVkyp!_blcmXIBW@ zvMmOM%*dd`jC>cruRz#eX(gomFzdsY(j$ zPGeGj7XOT|$6-rc1wwROvCkuHy$+#Js8W`o^Q= zdT>1XC4nV|e!NxxF!z{AoiHVcWyHzZTTI-H=q2<0`=;AU6>Syr*%r!AEPe#@U zV~k|Pxd=Oat@wce!tck^>J834-|6ZO<+#|E)0z?;^hxI}fD{PTAfc~=EIgc7%E-~c zS@Lo>ji#HNIVx<@t_3?zw|Ey^UCA-Im|2kb6?rP8GKX{;{&x$hcN@K)n>qZdAWEO~@AXVw^ZDIP7u+~2(cR|xvff+{~G_FE!+ zng?ffq}6j)uG27bf}Gyq0&D*Ci8l$IPpj6di7!Dn4u0C=FvbIP>G!?puDnHK)9{BJ zovCjk+)?Y@0k3AgLr8?=B?-JIPJ{gic!QX;ETlgpY@{F|dAq>Oso`?I5TngWy9db@ zBDc%~jIuvvi%`X%zL^Ks1m+7PC}sX925&SkEGScye3JR{=f(HyrVm79ACgs>&OaZL z{dr}KRM!Kt!7`BUKFC_nV^AVA5oWtKeTl4+Epx7KfZdGY%h8#J%Z)kTqzdd3n+p8A(PBQY+_5v=Pwb6V<@KEz~YBtZY554>*+ zgTnA0Q%Gaul&=02J+5jdsrfE#drb>Bie1*dN25YL!4MQW^yobp>s?lgwAE0AY!rDA z6-o??d@l^dM2=mJB6orRNJZ`f)6>NF4Q2xMUXp6IoZgkwr_kDp*DAuuzk;&FUHAcx zWLfC~{qw3I{oy+Y2Xy-9+c-znela(kNGDyKt+k=;YY`6w8rKTPK8fbvsQC$o54x-( z-KA5JdFJr{e`VP-uxF&UmByebD;pjtxvhe2&N)4jd3LpnnZ%Db}ZaRi{ zdAgi;@!uDz09w_o>S%lM=ev>}>T)sI3tQa84%}+pdu{C`fmph4pSwR}&UISkZLcIr zJ@&vLce4MH8RC2OPRYbsSf4lp7nCEm24uhhLedtYtCSoLvu!*t`tY01>g3g(9Ujm8 zS5Fw72}JtrRrquzZoKtxCIp%~lvy3L|Ja3CJ95we*TE6kToSZCO_;7T#JB@RhNb7| znVRT7r&H|&Fpnmm_<3}hpOP70BfuyNwu1|BCvwkwVg3l>eFd;FnoQ@$2|8`dul^mB z8tYv-@__d*sxjOu#FXFY`VBC&&^8#Ud(1jy6a4gBkoD3%_1W2IJ7JSMgj6rQiS=fW zZDl}RkDp(wkQB%PHv@UU?td}gQ+RnpuW}Pdh@&jvO}jJBTf=+x+D-Mo_mH;5z-9T(&!9kO1>3-n&?V}yw)h$JY`waG{{Lo`9Bqj+5ewh5&Jny^t(ddu+>LY1edSj?pgTAxq;Kkn$nCJL4 z80YHQV~!unzEH4ko$GMkP~oa7ct+*Im#pPiZ&?B{GbnxGMULC+A4VT?+dxIgoX&Wl z{4hJ;xIlD=E!~2B*YFG8OY3_1jqmod;}G;fvei9E3J7lVWT@Ve3?;)r<$hD#wBjdQ zhBjwzkZ#h7%H?x}J!AHOSQ`&i_aL$BSR^kq70{#GY9|EUa4~xMb46w50DjU0O z2*k%~sGmP_)#X}m%eJhY4IR!YvwDRhkONW_5_rvpPOHeXdzCysF{oSo?lIXQ;i`Z) z|Hr?TeQmFl!ne-1w?W+i;9|Zjv_-3!CSBQYqQ4wf3q18A5!d^{*1rLF$tUlxe09wz zwhJmr?Kgqk2tN#kM}jP4z_LT0-3uJn&c%500%>BayEDeJ%yT7$Y%Q;A##?@T>|xm+ zxB_yJVMl^-uaTMBaNdr~UG~ECe{XoT?KHDUPyBgsUrh&3F3vFeGN0>e{_k5L2Z>hX ze)%BHwm>d2g|0<8(ca@nnM(xEjlu9(*X&b~8H~N@*VUgJ{KkQhD8CfoE9Be`JIGc) z8Z^RYJfXRwP9PhX&gy>IpSIia-j;=QmVZOL0yZ z25(UP)4TdeFlBz|CJdEdGCgT#h%%dNs*&_H);~=o@N}&)*sDzZ}@{ zjD6}@u1|{ta!@sRFn-A!{mx;XC#&Z}#S=xoUO9TYV7V~(k*AAU^J6PzaqVfwWuE|1 zpk)id7&F9OZ%0O*zD{xR}BmM<;4i?#U~`*^&7D$^LfwUrtS^LpMPPkkk1=-}vR~haFT8d%w5*xym*N+J8_j;K?k3u9_^Y3sTsM3d9RH&kR zxf0v=+{oMc`yDjbHEu;<;a(RY&2iZ{@(bklVtHtIFoIAP;P)x}kZYv`hpm(@MCeY6 zwvdJ4){CczGo8H^PT8=^OnVaKWT4R}+OJtl!RWu)<40DX4IWqA{`#$q?#r#$+4pc> z6yiT;*O6T+4ZeW=74R-p^&oO>Kp)>r*}^%bx{>b+Ud%((d`QIwQADG9Cm-X#TaeVxwW)s+D88Xbqm!A2aS>AK44o%&&#Dk=Fd;OGzAfFzqz~9lqbR%8EW@)cH&af zgPizYk+q!i4w!{88N2?wSp@>HFBS?zHSycH>Js769OO` z++c*t`13ucH1)*R!`!OD;cNw6Nk8Isi}JdR{Lx7hLD%-N$`Qs3mlOB;KZEw%|J+D7 z#&>whWz!&uFI3NfBY%9!vsLZ7UbgX$<``{YKV#?L{}!E39c9lS{rqF%SEz@AOfUNK1i}f@qZv=w*Bk(s%TX@wj5BbUBn5 ztqYw2ZafzR_Q+9Ec*G26Phioa6TIk#BD1v~74<$m(aqNv-qN2h6w>YGh^BUB;G20y zrz|N#lXLJmmae8+1>uip-zl#ha?P;%tGly>QmId=e#ODVcjdD=LNx<=@n1tRdfsrp2ah87t=Ta@9s2vIvyuzK7f}{}@^CM9bsu|{WI z2aY>7kbXUR_M3ZGlz)DfB#~oJWv9R6;7Q?kslu{u4t2axvulWn#30gIGU>N zsM$!8xZ|kZJr){r_8p6v1Fm-GS~K>+<>;6C96;Pm$I^7SC$OH4)Y1Q>U+{{9l6-i3 z?ZX?!THxz*O6(2t+27$;f6%@RsJ#Kht2(D}gWtTR!XLPu(k-rdl6*YmnTfYT=DTf& z$oCMW0e&Sf((%jX5F9nSt7!bln_P2edF?xul5Y6z`;m7fMx(NKoUyOftDl0_2IGr8-<1zw$Nuk2@WX(rSZ*6F0(v&? zWWSEw+xC>syPr)`>C~C+dY<*+xk@>WQMzSHz-LZS^gelRg= ze_PTHeG<3j;ismqy}kmdxI)KQdSrxD4hHe2ci4RHsXIT=oR|VR2`H#Se{W_5vz_%~ zN*g^F$V6OETO4uiw)cD!*$X{6WsmKi_-uRiXgtvMxS<3PahdbMSKCYX!#Z32IkPr; zKQeN?;V9SX3Y*7WwzM$naE?(%50@e1l$5nJ9f+b`d}r4=ldM8iuL&6fL%;*L+X z{_}CFz^;#9CdDg34%#On_4rle7!2?rfJ)@7x4WEQ?ylTrZ4Xt8l^*Zc$3r z3J62_5Yy~-*fozlJB2ga(ZkgvxJg@#MqofP!~cbZv{$S~%kqn7+7~7Fv<*OT^v}!x zf}!oxWTU1WSFD#$-L9?en0x;5czP4nig1TV(U}tB-HC>OAjh|tCf#3V!(m^asUPzB z&$IA(?z#}O^4J)wsnwY(a#{$r8KzK;M$hAKf}FU(!JYOB!^D67S8RaICrLZGfpJ6w zh%_oEZA}6Pr$q7s%W4xVLW}G*f0+Mq6<(ldHm`*@z$Xn^J9J#D>@cn(c{`bTsCOrq zc;j8q)d9(kUp%H&w+#tqPe_Z*h*?wgfP)7`a0rLG6#60|#~s>P__;Y_tKX-3=HHeD z_ir3p9`^MMj|&CpQq-LkRdj5L0BgKoFH z1C@kS=XWNDodpZl?*{4tzQnMZf1--~Om?kxem9ZCpEH`;(7) zSus4}R5i!}HyIgal8w|$gB)zSuR?tlDB`) zQ3Gp+uwHsGy074g#7n8vU-(AUOfl;XyuI~i!7`iyOH8@6L(gumhWr6J85m`Wmiv0h zt<|VB`Fi{vD$)EhTZI5Ik9+Tbe7W>Yv z&QQ|3#d;CspeqdWy)TGo0mmRGd~J928g89sv~ZV2^$yAW_Y4lkxKM@R63VyoUm_tM zBQ7NX^o0HAlL#C|M8?!5gV=XL~0VV&t4d%TNlw?ZZ@)K3%S5VH@&TmV%$KxW`X@D%xYL#vG6DPCg z7j0OGiK{%4UX>lQ|J`UI!G{f=4}`rDPpcM87P22PFlESj{gRf9iEe`ZkMYln{SHQU zzj%%~{n540qxB3dNH66Lm^@UR zp6<*AN4^uhk_@^(0v1budeCG4uCuvQYpIf3`mf{fp3lMu<2Uxtdn*+2S%PjrFBVGZ z#3z7*i>fBYL1{>k0~-NboJ|PN1F5z~x8j>W_43E7)y-oMhT`+?6luwGhmgukOTD`Mm(XP)lMVDe-Kp<{T84D zqyNi3Bt>(9=Vijgh-icujNdF{)yYp7c#NyE8!`pUnv%93(bWDSa&SN79(=`J|1N9s zP;Wy0l>g_{SNIR#zqHZ#B@lKg!+!D|BS0@`#e!79xz}LshnU_c#jF=oz2?*G+mFBc_npZ{p`$%d@U z=whO(o;Z-UZcQ{fWk;6<(v3)x5+>{vMCNZi3~6i zkY>}Nl@$N!4Wp0a|NU16Z1nFA*e8fA=+@r5LP$S>9mRB}O7!>nuDgGeCx~80emWW| z*>x|V>EMK#+B9r}7&X)s0z#Jt1| zf6n^OTK>in)wSG)Smpf0i|NE!VJzZ$qI}`F{Ogba;p7tpUi|*c$gIP>#HdOuA?Z64 z>6hRrmpv`1fstd0NPk0QdkhIzG|=*{!tCc}k$S^V zCTf*7RbGWhS8hFc=tt8-o)NUvZrK0%Xm0iE-G$NPqUX^6AwGvzFL)-cK zUjI0YlqEN2NDE();yIXXH-YeAU{}^n2#bC@*>sz?_SQbtJ@Iqo2Dw3pLm08hH1Usn z$3q|xyVr8(U`DVD22Z@-T>SmecgTSuT2(rC!LTYLtVaGD#jDb*s$FVkIfCHC^NB-W zNVLL?g|;n-9n^3!;vH*x!6MkeVt(I8ftZ7B5qDhxHzwwG?$Si5S}?#*xSL4L&3B{* z2G*(aFY7${7Xp^F@<;m1P8~Y8$G&k%G3oqZ>&2qiq@V^@m|t4p3c}ZUgLI1kxlvpd z$Gkvae%dKn^Yz!RX@#0T$r_YzxeP66@XLuWNAJN;?t>9<5&0ws`K0nf(U^6A*ANm8 zRJUNIcN3)_YDcbj9?!y9-|s7zvn!A|rD?yFV|XyNQJ-oQ12s&|kJkiu_hf!#CaE%D zTu3$Ru6-@b3XSupL5O<;2lw+gHBnChxjURAo5S~ z-4NCrYmpi8_8ax})E?x-P1P=?YV=eUDdWKQQMYIY_YI7Y)4(?&_Ohb$ID3 z2VR^yllqD%k)aL8PLOrneb9*%w4#!b2=p39X_bgWJfYtxjK_bL<9Vy^%BAj%5Vr1D zInNDNU9Prs`O5^eD*J*QB<>;c(N1Xfj_ljh#7!#msG)*PPEv8fxJ)6tEUTZko@A!QEhf34!J_6m0?Q+#d=F4H$$B7vU;MOTCiy!cc zil#BzVdL(R55=unHKT3(+@eBsaacV!FK202+Bn}YuC)Kuyy`LzcnLZhAoPO0Moj#J=N*M(OWJtU z&Bv3@G{ggxr-On^oH!GUwPaP-<=-twgGXCI0)aj8uuRBuHslMr_|QazmI}_7ly9cW zC{(8xdg4pI#mCRFPWH?IMm#6=n&g}S# zLXFd$5vMsd$U!R>ByQptfUrNXz3}idu)H{Mj+kyA_@hd z$)10FUQb7nTyUhjG4M25qkvuSeZBhcFBfj^t^WGsfQxhK-~+4+#pp7QI7+=p_3g!q zCf9C{B)Q09B*mMa{B*QYupRUb#Jvw92OBXMYuLOsHyn$z%6aXGTn1L$4P%v`Z~d>w zm&aSz+z7PuR)cssuvehfBm2vlWsh57Js-E`5u@)vnEld&Pg2_(!Fmku{xsX|UcBeTDo>>Nn_S@S)M?%y zDUyv~d!Sb%;$i<3gqgi`c=no7@D5W`53Sa@l^JzDE#vs~KR*{MM5#v}hAa4i7TT{- zjXuq_ND2XHA%}7@N1`k@dp;$x=y#XbRwe^ZB)YkOa8>bQNzuDK2(}ee>_G|sj1&?= zIzVZZ`)hjMoQwJX;l&W*mQ)oNaQze6?ep5C#9CbL`be147emvn^X zAAGA|rA*jFLa^I%w`V*XWzBnmp<1P}FbbJ`oP5ip%8#S>@qqXNaVEG0b8}to#x`8j z91?v^^*y+$)%+gdo(mdY|ip@MZJJul-grN8h0 zt37hb6>tFXfe=Pz;bGPw+heI3@v!Nj%%Mh?KiZZgXR>&o>NOs>UooONa;J7Tc^?M= zen6kVcfA-5;Z|S}%TLH7|F4s*R4iwdEXcn{@dehpj^*Pjv*s5vKz|3m+(CWR?*r(0 z!uPeV28vm&($$dNos-y{|KX{*@}ql-)m~k&1^fC=qOKOmiHZRrL#<6xp4c2UtJiQ6lHoHC?0A}?sfX$<2ni8TA2z@H{NH-Bch z)ecrP2CN+G{5u`livbwz!d|GnTk z$=h`D7voA|Otnjp-dm7^CWDA7%YcH^$bKu`dW~KBCTC8_SoIlq+c&xp8OL7Sg>_zT zPv5qZEKd)pJ0wDrI?r?v-N2>aWi?a?jeoO|NvYfHvhEk}M$5}wR$ZxH;52aQ&awUM zMG*wPmBwQp&V3(m;+@B>a%`9$REI$v7(tv^y2*PXcL8!sQlYqkuOToVk%*0Eq|@g4>_74Sfz0hK>OEQTvv7+~s= zUR+yQ7+CB@U_71i#)eLtB)42ZF=;1Qmuz7L02MzN5;XkoJan{Z(1^1oE|CfMPcMf( z_-$Tws?)n7H)7^nm0O(s#<@GG`$QXYNd8A(n?lTXYY}?<3s%aG*V0!wZqUYa`s`N9 zGPwcCt)1oo2OORP*lrQXDMnysaR>%}Urlh#X~=iS{#XJpedC zA*f4&n&)g0W<1-b%}BRzL6NUoa+jX?{GFW9+nw?9r}tFL5-atHQN z5#l7iWI0OrD)_{GVzLGmv#ni7wgy9az~_&T!T^W~>Wr?NX?S|euK#rA>nd>XDOX!t z7bk2ytbK93l%EjJnYapQJ+zAdw~7J8Ljr$nuRh)7jH;H$zuQ3Ww8q#VG?cwYxLWX` z-oeBXOoO;8bWlb=6H>q(zK;apoJCg;IACLKSj>(FslFUGA2J|ix$IqPBmV2Yw&s&F zUZ!9gpm-V*Bp65ds&LK!s#hELd;C+?=E@hWcM}LRad1l#SMBI}R*5(4X5jM?hyABMkdBRH*kwbL`}mT`6udM`^A-*I7{03JQ=9fW8k;*D$e~vd>yXv(Lzi z+RV5(zW9Ia^Z9ms=C7|tIH95;k@|P*XW&?Y-9u}mjslF<^!m!cCae9x{V9p`q}=a` zm!DYKt?uDXdHNgDb;y?R>H;o?$0!oQ`hZwySeB*?OM3q`7Q4UwVkb=vpPc*f$aBv} z-KUCoO;+e7Qx7i4!R5=Ya z&JS`>u>nyNotv1~;n{Odahn!q4+^hcE_S&U9+HlCLa=;to-|8$oJ^8`T z<#e9Ii5z#XqvwO&uf%*ARv<_i{~2r};SW9`$nir?bLGw!U@=pVf!q!ij5mhqjo z`sE0R)E~Y!>J7;_fQQP^a|p@a%8tW;2OT?uuD2h*XkN}-OT(cQUZFg9A4}nboVG_0 z!M)#qgA9S`AxP7*f{C686Q{|hIWctxz zL(De3=htAFM`mDpwdR4=z^!;25U%8w*pqVN5#3J(`Rc|>!*FKj0zBP;l%ZI2palX= zNCYW<)c`rVh_*Sqwn@ygPFaq(%KPWD)zqoPppmp#_ikC%)Qf)R^DlMa*n!SR-W^kM zB!p)Hh@Sor2tBB3grM;Myc}kSB>noH8V3|Pomw^zl3`o9vN!Kx?qyOt8uC2G@C2r~ zQHXDv+g-``G##lN9n3>YI*|`k*-esfHRFCI^q9zg%m+sU?isT7-QDocK`Tnxtn!nc zW(4f_IwNicBsutABe?qS#{&)lqmTT1ojs*i(3Bne1fzCr*$eS6?=u??^4gIZ|MwSa z_8F*!pPjJ7Q*@h^4HE6>|C&DU6Lw9===zm`pvO0+?FCX_bsa3=(Fjf^tuK*ZYFs)8 z9!XuvI(KD)iwpkJWW_Ce}*#1^_{1Kjr#=Vv4pN)h#+9J>U^e;zaC zcrE#3Vu;Gu&fZY4HKu333>75jp{>KlKQcm6Sofni^82$z%`y{(`Dc#>gtU-W2c{%u zO$Iq~Y>LpoX;xY_RJ=21`Ix{zYWZN6U;KHKi&v8?ru4X9*b;g7>fCR?81^ZSsz;kH zYsl~QKEVMhjUeRkmgg8F_L-wwX-*N8JcVP{1;j~q?1d-|Wp+3W-s(?|o>S+!1>{diYC9l7XCBtGIae>%=1`q`W7&fCX51Xv zht3xtR8q*do@={WZ_ zdt;m+<=LS6>j~E>a0FFoYJXuk{eu~j+FBwN!J)S4*JU)jWGJolu@-Lb^4ExKTN^BI zf^$qz6`X3wcOjX|a7co#ci#P)G8V}0JA)PZsARc~Pnveh#ru&fn=}*KzYD|w`N64! zV8ESn4A!yLzKNeJcJ9VyCJC-5U;MPm8I^d4l-tR=m^c{jF3LUuIiQ&#{EM0#jMFfH zw!!d^S#A}yXzM5{$JJL z_H^r9{zVzUa?s!Mz@@$Q67zkV+3YveL{bdy*4YyrVR)dDC`ocQ>5f-dQ4BV@>bdvl zKn}J6v0hmpG3&{c!g2iBqrdILS?wwJ+MHP=x1TtRb`z!C`gb)+j&KvSq%hDTk!w(P zm?N<>Xf@4Vdyj_qWtSD>2WRf1luWnmxfM+0b*>#7NN6qqIaRR(OqO%#q?9tl^R0F~ zx6Y_XUuSSS2uE{~fw;;%q;&4#?=|96K44ZvfVYLrbN3bI`^tX&7A|g?JKMZ@+riA0 zwr7g>jlw%@j_i4wy7@~tiNToyLXdKcQi>agHKxbI?)YslIkMn}lQB%_RdhtxH@@Fu zxf0)7@%rhnwLdxgZw^rdEBDS3{lgL@u345tdE z0?@kqbui}1N1-tqs8ZtU-`~{u!$5kjH`)EfWYx*|wj(@hN*|ncXy61wLkk4U6%1mw zPdf+e(@M?hCYK{))L%_|<8lS&7GD)bUKhR)GT*gxeG25@g^3u)y(x_L3o2+`)H&+9 za6;Ca@P3)=l{>jjx{d6G3p^`3!I7e2UqMa(xV^~VuYErr-5)cZt1g zj(k=pyIVV5a=ALR_%q4ZAKB%PG$<(GX#!eWoe@wno3UU%q*%`eq(T9<%lV_591HvBvJ|f)7_$Jz|Pu{&E)c1Zy{HKSwRr#O1 z0lOctH|+D&VR|7@!$(rRD{aT z=<)gjFyGhT@Q1!WrAJuq`i1^qxf!>v5&=!+Ps6<(8XF@1hg*ywrwq9}XpoyWj+O&+ zLQOf>Upr!KW4!Et)%xSi*NM9;O7ccZ+V7W&d?nP5!@esi!aYFy!rvU`eqX=}e=kiv z=5#Su?&F4j16G9j(BSDs{>z`|DTQ)*9)X%x2D^;BX#$a_I;i)g+eeNHuS8lK~fTakAb;u25TZZ%Oj!Z!8SwbqcZy)W}{Kvf___G$ANIcfohrrhl zsh0;;sUlVnP&}Yu4jg;;P%l4)}qtA@KCPH+IB=LN!1TPVRC z+^bzwV!>g--PX5p?E{{Vd3aV}7rdWkmh2^}wzr)+T?nr;6-a|XD}u@-Vl)jOJB8rwI+dqo8mJa=u8eJUNn7Wf8sd zGm!g_G4H>BVkO)@lJunW#>Z6*=4!hDWfad^~1;GX)LFoA|_m*w~TgVcn9NTT1CIVBUT9-p zjXrghEZ4j?(r--u{VOQr4HX*1Ah!|)iuM*UNhZv*t)c0c+0*XM>wa7qeeWDp_bkFZ z`-r!1y@mWBVi>y z2y;fdMp=2UuhPAqhvPP3KP)u*Lh6MC(?+4m7lcuWNP7 zA2`wH_s!`2^yS?V*44e(b4we8DppyF-$?IdEdYNEdIkZp1NC(?IT)KGAz&k$9x-3& zBR5x3WmR$6S4!Qa^=*&LQK2gYx18fYfenXlX$Tu6Z~-$K!0<(l*L_&>*p&B?owTu;)6uC{yq)RGM@AfX%HlPY zNoKal9eze#tOOe_3Pf1+_kBRpyW#uXM!1N7Nfg=K6krt^y~;jK<(e)TvX{18he_Hp0Rt;RhhXFu6n@9( z5`TfZwtLe#@WYMaTb&V}0c6r4 z6??fG{S0cN&2scqzZ`P7&Rhgd4W|pa+;xZE@}J5=Ape+l*9-a-;dU?|i!V{LC>n zdys>Q{fJ!SAvBqyldv9Ko+V3`XVpm#sq|*(qg(#2f0>JNj}k9e`xMYDRG?!w61=NJ zUdW(gTPuUbtnOWtk(gdP<)`IgFVXAU5?Di~`-8`ymMg&@f`zI;dqALl=qC(IS1(OZ z^<^osmT;brG8=E(Mx(XGmE0*s@?X5Q+rPUmyr3WeS|d_2uDk=Y+b0IaAInl+)z(<$ z=@Pu~HZ_*F&M0P5U4@`3MrRr4RU`}tBwd6{)zgk34D3{FA_&XlVbNg8d*NW?V_}mq zVKwY0=s=kM5@NZVQKYrm@Td8o$eR3>`P#{@opHU!)$xVxVqAHR*=m!ziLcAi17&zu z)3SA2En$S_`K9ZOx2|GYYtkpHPfpLOZB~8>^@C##6%_@c<0$Gp6jx!c@zAl}!W?5Q zVK=H=8dc?ES~)V_8rPFUYxBOp=eu3|r5)se)_}0D*E2AlnSmCE-}KJJ@)TKN^jp#H zPirDB6*8YLyteiBeyqSnQefM|I~H;tP~(Ms#b~#ir>xs4WsUgTCwosFo2V07_q*7Y z`!{@PBoyb28vS$IeUk+G1|?SEi_sdq$#0~tMn~5Soj#^n{g68}xRfBx;q&#hJM0c8 zGV@JDVK^1&C5YC+{?Ot8u@O3UcSaI@-gri+U8t;({jMb|>oorF?To;VPV%FocdthQ zKnX#?V6?U=Z@}2H*9uNeNn&^ULMJt6pvGPwiq{ci4D*;3XA%rWi zJ%aH-r2e^)8R*pYio@pFaBkvbWA^4x4B_{C&z!J1yCqaI5rBF*A5_VifI{Mkt@ciD zoza~YtVq!^8_p2luCTOt669m|efE@eO~GPR{Pun)Twx@5_4`oS`(Z29kutbBNC@qg z?}XWHr!`3!h0PB=JpPz0dZy^JAs9~y;REVKcpye?aO5NqYn}RXz4FDyACEp?TMXWl zxV5DAIe7l(N9MDP-I`zo`Jvk~+8^hSkkUcBb*pKXQ>>NoRTQ!`vhu5wZA+y}Tc04r zuNrpNme0>61iAhCr|4r@fsndj`#fiQTB6s>JT5*i-hQ%hTMo}ugY#=?o2*AB-9@(t zWT3qz6rp7s`gqlKW9E5M{Z1X-^P@TTtF8S-mQ2glLB`4bw^B%l0;GxtHvPa&tN$9b!`t2@u*8^@}K=JF!NzI&YA_V4fHq{b6~oCjb4qlcT>!`$-3 z|8y;N1(%_hlO<(Bj4od{&VfZ>qiXOOw-ba4YhZ&)Ip3fp_`=4}o(J zjlK?IBK6gn@4J7g%c5&bNHs@L-h0ilD+;T1y0z@3?tpIL6=Jr;DOE6{(1jYw6sw%a z7=;4r+tfnmMYl~aZjV=KSKVaTRY@A*%_8TmjlL<}V+}zkRenfSLhoNAl*B>SWu=1h zBB>=*F-0sAu|IJDGva_G)$`*1f4OP87pjA6Gg8e=6g)2V9EA3D06h z&42%W#`iR%&O@_sKF7dp;7`zqt3=J6$K9+03ZI`$T}la%1!D+pf{<2<)d^nMh(kmp~EkEr$=Zx(Ff0nz%!OT^X61mLW9u)BOUitp+RCA{7LmRitw}aHWU5jJ{ zVlB5|>7ghO!lua!z|6c}$5-g4s+{B7X}>nss$X%XF>AeM zA+2TNT^bqLcp@C80R43lFX854wrM?c`|env!8huD`f7HPQ*_IM^vq__JM_aQv;Btr z3@vawq1zb}6pP9wJ!DA!cdh@&{80;!%sxTZp4F4u{gX|D;!O{H*^|Q0?+N3{v+}jR zesKR?DyF*EOuN&%nWy;&=d+%Lzha*2HPXDi|FJE{wK3Mz)E@8nZP1;N_l3}k5|=Q# zrQW-?RyO{E_L>eQXIbT0<>yXUQmYwHZ2WRD&QFth!3DGD2YM%3cfQLZLC+p_=KpW2 zkD5I?O1n^#^Y8k}Gq)rMg;d>sO#IfY9kV%EIkootRDItkVdaQ}$MP2@O0{$=2lX)? z34xcUwib8q&u?6|zBZ9Y{lktfVCXf}3IkR(dJ-eGXtWPo=5NR+lb~b1qO%({zCccT z@nP3?$(td!wMT(v(Jv$?ocC)^i6X~+tru~tp&V7n2|-uYUtAdpQovp7X)Ms@3h0+{ z6;t$Adrv?Zf+Nzcoq4welR)3KeeciH!SlAYiE>|z)$z_>pyAtkwnBI=m7=d->tp?X z*iJa!M{T%>10%pCG=KuM6F#nfBA-@uyV?#|)T!Vxj)OlHfrm z?E5;B|2=;mbvWdaBZ6AqS15(Ji2vpTWj~9i)Rms@b5$Ol#7vI1sVg5z*L5c?7(3c% z4iq{^hWRu|0EuaiZcW9ilU5hy!0$;xx zyt{+tKWj*;(z9^Of0c!bB8f?{@Tg7MnLiu48I#@FOwk~*C7)Hw42RU+y*e+0em_QT|qX!gc2J~F(I^IAfw zQXBp5Ham^)kG=SJJhQXwm_Qx92)5)C8+HXy-#|`8B6t(inCS_-5ng6av`bA`8rNx7 zo2Mon!A)1@mPk-PTf?x@R(K1h2Yv;#_OAJX1{!dG$4c5|R`$AcgQ5q*!uov+juG`p ztf~Z!xxSFpdr+tbTsrVr9R&Wy597V=%pQI!3qReu7GKpys%EAaHZFAaj%;anT@&D& ziHx|p??@GfJQ36?Rzh8VM8(tO)hu`lH(lZt-%Ly zy!MOTqUZVPkdw;O6gf)Zx>?#{{{5D_)Tas8;xkbx_8AEzN4mnetTTZ$25*>yisXKW zNvo;zd+H7HRvSXSNr}~L&qWdqo)b}u1kIOEF+Acq?+8vLsBH(;CQA?WEm&L6& zsbv#;6nLA8HFk$4qsz0rgLyOO>TG22jXUZ#_n)5tz|i0KvJJD{33XRnm%W=Z9Vdcu zAK^wG#mbrKt-AM6XrlD^J1ld`P@wjT(>%$>P`NMDtv^qFVexIG9>4TER>Ucu;=8v? zeq3$SoQ()^NJw^raTGx@p#fs%SIoXmop7TktFG6kUrTjWY)Vc#!SjSI=V8I5G>dc+ zW0HD2;1fU@h=YCvDPIHtYhfL3T+%;z=Ed}t#dC&lJt&Ao_v;EF0ga-=V&+}4 zG+Q#aE=@-EFu3sc|H=^_(h1o5Xxzi};+|>6*j?b91J6YaiNs|dR^{4q_^3S7tr$K- zZ>4yG`CR8Q=7|VNCIOa_4>3cm{H@&}2e1uUnDkZ5f@VZ%@(Dkfsi2;FDcRX&9{za< zJB8bw8dq4^*u-avYI*;?D+~p5Q3quliTJ_=GN%!|k`vyNOpvwk)vlKpYl-q5v!_#k zrOPnW#q}p102IZP1rKO@yS?b~U?V#FB)#?0j=na@QJcy6PV#7`z++pawU)3$gm89bw9`mD>Q;E1>N9F=EtCp;t} zrwH*DX94FNxp)LeMOjRQp=PiZZnx2KW5J0JC+q}n)fPlM9BnmTPKO*og?)I3KG5wk z7@m^hrAPk=j?hkAc*Qr<;fpUyZc0(~Ov}f`ie}=Po@gGt=arxq8)COMF!zUGHsB9^ zyNiFh0=dMW##KC{&w@rJ`RRLEJ)xM=>rGLqR&MjCGap8iwTDlJ8r7PAIeok)VGLc@eUO8MO5{Ei4PfkKX1bK%*XzG2FV<(MZ_(t?nAG)? zk<--pS=c@qXS&|@8$gs8l&3*2XG9SCAqmUL@a2hX($3Z!9okdrseQuQF8l(WpR%Q5 zFFhNfVfmSQ1>{r!aiW*yA8^kRwI2KW-=!PVyg><}ogaxbw=?kAe#vjTFyDD)X}{K% z_#9g0sw&Yu{Y{V5ya(?jn7ItF%8dK$Iu?EwEH7*V94sa>$R={a{tuv78fzcIP4Hai ziB(@1vM6-Of7mTQ%yoZ;=v!~0v&HPh!G6YHN^`E)VT`-|my2L5^h9^7&L0H}C90eJ zR_(8Z}|PIRV; zG>}UGktOu~&krC)CqM6#0#S$pHPOGQ&WuYcWHC!aZLGiKU9>l_lD~}nz3}<2XD9X) zyQxlcRu{UT5bWr+z=r6z<}a{MCz7w-EW4%Z+rV;Dw)PJ@#k|L^l+*pP{ih&Q`$X?d z6jEdb)ro`lNqGC9lIc&)8>Ci~cJxc_#x=C`PgcI!^pKxkY*K}-~JR3`pCe(-@* zycBVM1FcOptEy}A2G#GSV`BI}agj^kdDPs`MJgoz?Wgfw5XfjK~DJ{VD(UAJT6 z;&XBq?xjr5!ENOYO&fIPRFU0oBXs#tq(R1A8 z7%s&L7)}Mapy<_%8OF$ITBTM52$R>8H8>1tRB9U(Y^j`#*ZxlLN!l{+r~Bvy$U%iP zMDEKs%&XA3s&-v>>ZM!F4{HCyM;ktABUOaVcI5>8bPQ!!i$GujeipdH(c|UTkss)N zQ{jTrvHIh~CD}bHD;YJ9920HIsr%Jfsxk?m?B(XNLu+WrK{%*&qYXSYe&(A^}Z1oWJK|Ch^XZHje@<_W3qn)*G zQst5~_*F$9&Vl%~V-hfaZHm6o!2dY@?zq?bHw2zd-)&p58!suhH3mb< z4`CIwV)Sand>=XGkJFS5zb*CbL>sH^XKp;25E)v$rYJ$FCEe#|{|=Zi&^`|iDC)q} zjG@mp%=201`-q1I(xzSF&suI)1#CQP%y`GZq$@IWw0PtQsrNaM+jqz!aJLzwC*)a5 zusQplC+Kr$&ffkzMjPkOn|StfnVq!gLX<>Sd_BZmm4y(VW5o()IE`q_Gma11(oHzq zR6@s!m@^y7O=_fn@RMc!Xb*4OH;1CoDGtf$cvFg5mXbMv2hAzmM|;)(+=htaoRtG$ONAkEbXo7eLMSKoS}xr%MZ8b81N$B*De(Q zT91wIQ&Ope;HkKx1P~8V%Tjvi$BiBnCE~G;F6yc*dR@(o_Zy4RhfQeg6rt46i4cWr z{h;?D_XJu*q2wBnqNXt3nIx+3QI}+8dfbEm4y1i@^A~w6P)8Bo%}um-I@sovCzx%h zd4n96^={1ldpokid(1n3Bv4L8j-}3?yyr<)!UJbcr^2IQmx?bP0eB&y2)!E6+YlU$ zxqstzA4D`yzWNsKIrrj-rT95Iy}u6jl{e3qvz<;%ACLvFjD*U5AvDxHSDvBA1GVI% zM^3=yPf*hy%#!Y5$$!DGd6pBPOg$z{G?6oZT=>%lb8K7I!VfIXv?_OC{k&D z%7So|k|OY~(YPeE6tfQ$3hy=5kH0Wuv^u#}^fM>*a?sZn@vHa)bsxbOVm+?Y^1EXe zIsv)Wy*9(* zz4G)?q+RpWpS>mX^obUlx@STUz84Yw&ME_ckOIVUP{*|d3CF;3-F$H?LCD8w??ijq zmm@C~cH$tDE)w^%9qIEw<73ZvA!?@zK}qDf)!#{ip1wTH^#Aa4;M7A+AMO2E>2At3 zuD;B~YJ0MSSRo_E?q&JZwCZn>JNV?nPqXig9$1k=k2c9L%{UYGUwQf#zODBzcjP7s zJCh4I{KnxnNYps9|N4eF23no0OrxJUaBb!^BItFcGDrs4?>-P%;bW!K`jHr$8&%AU zn<{3yN%@e12tu*^(83S(;fWb!gr{Ns$>sm&>>1Gxn>VO<^-6S_#^7SxQKKW5zHd5G zCkrmh(eR79mEX@G=x4h;*n6LWrRBQXp!@yxqih48&OGDfty{nccm*_X zBwH*7QJf%WMse?QsJcVKzrp(+dA6LyGN#X!!#*V&#;6;#dzjth1|R{P48$Sz8wk|M zfhIlO{YW~(Q7_g0b;mWfA-gI*2lqPTNG7Wd?;Q%)kNS`hph)v?3*!e7yQ%hEbmgVc zxt2j{l~%Vk-*-y#QHph&-12JYm9;o22NFPRhR}~WBf%!RFhkF0EFfeSTin291 zCqenCQb5|pUav1ZzoLlemMh?g{gV5LA=${pDB5exwhS_bXHU!Ai!kUkkM<45@46||egFY3BvYRPB zcr8Rcy{Ubz$8xSaiibs1gn@rS3<7!xt{p>&gCIBf<t+T07LFJ978bgQ;*kf=4B60&rkq!91 z6o{&vvaA*5^XmKS$DG6S%r41~kBNBi;lE;O;&ZntK~5N2f1vS3ekbPp9z0O570)Ah z>~me7>a!Ydt!U{|Wl74=e3A#F+ws9l@XtZymclj?vl(`-#@f9UfbI;UPwE`0dgXc z*@ix6eWRFl*-h;%h+b|J42xOBvmGjZrq8gW(XK`3vOS8m+%+a?iNX!QWJaw^-68Sa z=hl4jk*6hc#ZAk`Lcx)QfpX`vsb4-lHKzM$GE2tl7zBWYpdlanyljPI{28ZzYdK^{ zjur`~^gnyU07JZ7H3dCP-dX*aIRxxZNp z^I|EgHIHOC*~(@eXel^>=Sa98n&OAb)ada--V-0FOYG*N@(M4ZC~AV6UN@Jdz7?Js zh*`DTe0<{qdph2n4ijW`iqItVWAdl!S5*bFdn>ox-SJw?x~;mBJf-^-(n@~b;=E+R zz4{n%o2m%(yh4xT<%7{DBcHw|{${AOVfbZoU9>7wR%4PYnpd$Oj zuV{f4AFfX#26(RM2c=w^ziaOvy2I^gI(Fx^_7FE4AwKR)=8N;+z9)d95)y&xL+AyI zoX0Q^G`wAiKipl~YjyaR&-uX0Ka6tdj>G%KIe(WE%hU8#j-aTZpb26pCPGLFX~58v zdLf3M5&io=$Yk}KOZro1(FkifZD&KWz!+jb+zwp3w-?)fuf1nm@;5oSm{`W1=OZ67 z)+H34NV#Vx|B#j{x8Tfi=U-2=Eg4uoB__gq6KaMbiAw>Km<1<|zJG(2%X%l2r9kbG zkl;q0m4J=aSnwxyl86@RI~QC)(LrN*1ktQ-kfGx;=nPO)j1ignf3V={gXyPFLgW@M z$1SJhPb5YwsW7a4ucYq4GZKq5CQ6GwnDRyLfl!{ailJOxyYf~hH_vE2^6yf}{cy&X z&(rtG?om;=Gy9+!eYPTyqQd|Ns~prmbUr0r*0`^e-mm|CEzkw44M&85?1HM^icodw zb+|K-ErL+n{A-a?^!Qlv$W;GNzfjYUAlv7_uljbn+%AyA3%*41+pj6MZ-{_#I_Twu z5T4H!nyTHI-2*ImEKKlMV#WPuwx>5Quzj^GY}lCfh)`uo$r3N;?fqGr09X)eP$OkG zrV}tP^&V3Db=vU!ZIXUY`clPBai%t{q}O_8Tas?f7tCY^AT+|S2y$p7u~UC|70{4Jg^$h#`m8Mcp5ffh7y1A%!rfceWhK9%o8Nbd z^Y}|GA0wUhaB_tUV3LIRp{xN~ZUxDBh4s67uh(#u>D!5s0-|8Kj!VoxbNxs0A9yRw z$jgN&ttEnM7rIvfxdWv#-af~CpLmQ|)aVC&suK%(f&|}ou!r;#DfK;~rCU??_|(+W zAh$+X3CbFvZ(P-3T~75FNjnQkw}zwTMBzKS#qLFdlUC-MUo{Ee=Hk3@paYLLxbqKk zPom2)`+#5gxgyQ0cIy3+lT0|zhn8t?u)gK``78Nehm&H5B=!QxDFQY?AHSk!7|Io^ z#7U+2ch8dEhHj5D%l72^y%*nQ;Pv2P z`V8%$_C&@DVnK_R42k#0H7}n15V^#V_GLB~N{>_J zN;f_{l2=3*!dP?uS{)!jsEvp$W7J`t0N;CoaWae6OG~deJ50J)-P@8t9rgh*a$j2J&1ewJk8|Df=6F1uOcXoFg=5OzPvK{qPI zLms$@S&yuNx3nZQx6Q+3*FMbuTk1(UzBTwMt)r|Io6b^>JVpx;rwYx#CX5A}rMI;n zd1kqmrAz*4cd^9YO5uxZSfLl&$m^{JX!4nqXB{JprzU(8n1wyTXm&(W6%XWkl3PsS4Qw6x)B>)B>mn{QG9?0p~#Lt*MyHZi*efxv)*LP$(xn@6;tbW+?=9^_}xI8=l z4~pZ7(-b0cK^UhjbdjOKjxwkv=J8ZH=hCx^8%+QDKE3oYUz@-Qw4DqE90o82iPNx^J@LmCiXhL-ZJ)2o?pByiz76@kNd>nTBA>NhqHd%3CdT`{HG z#-eKWnEq=-^-A;lgDwr*GF`?-l{CO%K<-82Jo&(rLY_@rKjKB4%yhrM8j7X~B!-G5 z$$B3Yli6-|C9u|7ww`2yu#%7na>)j|Fn3zX@ZFI&VWhp}dpy*Ks5u*BG{8<0DJ8pTkDE>EB$PG{sLC{6kFcME19g%31iTnq~Zr^B-A#IXC<^?%6Q^;Ox9m3bis6A%O?An5q33FdWzG z5;1d2RK7{-h z&LfxU|9L(Pa;tfqr@#jq66zAca~?I%p;(Nw_SMrPI8}C?eWrSH?YRT-ZRW-5_a*#y z^X(sI3mf`P<6z?TujIX(5L zeIXI44QL*^jzba*YQemq)fy6S7x$tTdbS(=;uYDwgnkJfkxpp)Atl7rp?xwUJZ|kz{z=lDZu=lSnb@FP%}m{Yr8!!^mq;6V@5JFCfn5t^lN=H{<>+0gI!5 z{qKLGJ^)SgT7Q1TEWM=PMIp-RDfycss;|_?9+u3}6&I*#MBLlc_dEE2NRQ{?-Sl&= zoyVhwnw_G~iA~Kj6_2GioPW`pd~xo^KY&8e`WJcC*C07Ea8Slg9SJwTT3-3&>Gbz# zagKTi6FJReDy}QLH158sDSfs3+7Gg6(FZeYodjKz`oA#uVEX$27&Y-76cuUxE$0I! zHW`u7NWZr+C!0=<_;lBNIVQ=+bS{eM7k%-GgNe_|oPCLtIow{De0)``sa^ayP5xQ( zOp3GqW6HwmG4sT*(JCSbeCD8!m;>T)``pBjO{vf7k{1ZagxTmVe{VId{{2c9TwZb- zoB4SUU@B#3oq(SB9@3fsJ~+?Bw(6k}GuKDM(UH|g+3Q}L=g+M!^LtNr#AK;>uAbVb zsX%oOG+2p2`fPxlL1U?&|yMD)arnM%Y>oe}@aN30{-L)Af z$x@$;{P<12t|$EQRmoQXNl=0qi2{FxnpTLJPHGGjXnIh{FzdmQ|M_*C-avwS5q3KV zxf!d2rm}!)Ab=KOn%5sOprzT#H`)~Y0%>PGCrRLF4V4w4d+uF4|e-N1O|#Q4P*rEFK>4Wt14Zv-?3AUTvUp5!U@bd|B=;w3nLS&E7)HrC2nGleH^ zwr&2b)LG9Z_5wLEF=%a%`o0Zlr-SUF16J|d7z<`+8);fZy%CTY);xNOx5~1yDY$~K%|d6V>Z_AxKg$NlsR{`r3MLY%D**S6 z@wB@3&bHOSj1dIF;tRB#yh#Ft`P zzC5GmINNTK%7Vpmi?zD(jB>}8%{?wpaE~b}fg2A!&;CfvJm;TTC@6+nxXdq6_WZp{ z9kitPx=N)`5AV0qx7&(|Ne~uQg4jFq>Tg=dkSAOQY6J(o)GQujJH@gvOWeN~$;tCH z)#CAYoi(Oc)!BRi%fRc4ej}tkMNbp9%~VyGYko!cImKw&8bN7Sp&HldnP{&3OLJ4V z;(O1ifnD6Mmx@fY41&yvw{bcQ`{ZZy2KFMw(hd?i?FZX_(!aJ}Tjk}^_YT&lhu{J% zgEHty6n4A{v)y6U?2aS+ozyn(%lnL9X8Gfbkt8fO>Jl0U$BWB96WQ;KEl%_NGdfud z=4a(~T3ql;$CH?=Z8K3)QY(-B1SPtA+oCd$zM6eis0r!-s+0f=1$C^(!!Xy)51k5L!=l7YrglRP07Ce*hBXhw(;<5`L7w)HLUj z`TjY5=Et#;VUEbCH_zyp&pcn+YTs-JIq-%e-m%WZC~?*#s*`NaCfclA)2#!sExn_g28dVMH7$DD&qdIio*5e>fh?056s_PR#*F~Q$cE@uXbops);ASXDMLwjj^5?G?M@q1{hxfB-OVPsg?liRpD$Ugljxo%H{o(Lx=wl^Tqn{anqrA zo-92l#9efbSu9)=qfAAimI++08!GIKp6&MK`i4O-h3sC3WE%>n%u+f-@!HihnB8S8Ff52P%t3tXJU z6{N-HRoj|+a=g=Uz4ffB-}tky>fo6XRN6NysLxtHq$ofC(9Ie1jAmO^o?J@SWPz#Y zr3UZamYWykscuwVmuvHe>8U^`XOvi2HRkj@$+&XlC+o>nzkJTP@j=c4LuZaZm#uHT zGEIIR8EpCoe6m8S5Y#{$hoAA7w{R9ca~NGoa!7Q;nD#Y`SKr+?U-w+HpCxoIAHAe- z%>z6N(2|ZHxgCAO7^PNk;mb^4=()I=U1YC2X{6WN&g?ELv1NFjrjksbzONMIpkxhF zO`-A=M$6!)izQ!}HKVfqD0;?^weU7}^8ae;%HyHjySSx$$C5Q$gitJm2K{s;A zy-A`XMUhaU*I@Lz*AlYN7@-Va(VHzvB(jVx%~6EnVFJgg{L%!U)ljM%?hcSSSmsJD?V>`2_@HN`Noj{W>=xvwi4l|8p+-Bo37Eu<}LkPMa5yKWO!(k1xMRZ8^^rzV0O zfN@0gzR)j2HnZ`1@a?N@7( zqg|3^(x=|`>N|w8FYGP7w|Lu8%I~J}6k!fMZHd%WX8)#6HYY2WVL<807Rl!ta$mmv z&j78bxZ0osH@%O1?^6L_GBYiZMx^^UgcS6{vXw^;NoNlhaQQ1}SdJ0L&Ej6Zx=$iV ztC?f0peXh<){f8&BwPipSt4Zy)UWl5Awo6G%|rN z8b&lqc+Xt5rRamky4@4G0!<&{>w0(9*qhBdWMv>BQik&VVj1STc|{8Bpe;7yXFuzv+y7$Ipiqvkj1M7n>gj@ArjZIY?y{fQ z^3h#hNkmVNlIV) z1kM5!gajlciV<0b<4yP&ZZb7^IZh7Gm2!&Uc9hf-!}Awgi*%w zEx%=s4=YYCanD(7esK3_wpUA66*t9-+~y8CTn9U7afncDgRIhH^BIv; zuFqSS^jofOo}^B3gnZUbJEX5vj?uSqb~^Po6706ytueM49x?|IMo=+=BHNH}(U%$` z(G<0Q`22D`MyE_V;6zkS+$U>8c5P5SwopUzDF;fKLE2z5Wq80fZ;R>|$k{E3E-Q*o z7K!L|=Hm%Hq^i}j_XIEx7HkD7i89el$5q zel)^6^%>Yfi8Qk8qpUA(i3{jsjG;y16t+lNL& zq9P;s(TL1Lfh_4?Auf94w#>AVdWpSz_v*nT#FZDj<$SBSYz7zrK>LJbY2#|k| zP)Aln9@KET)R>`b?^I0{mp-Nw|65S+ zBSfUOd{N|^m2Cas#n*zLcX@D`qP0yyf-)Qf3(zW)o~6<0GQ!&k6q+9}&L9HhmDBUjut2kzOR`1r%oocVvk5lfCD^cRr%kbJ zj-0^1gwqiyqX=^)t`Uv>?UBj>n;=sZS&9pHtk5)w{F7`V+VIL>rg5a5>9WTlN^I}njo>OaAiZKMDI From 1f5763f7877a59e933fa729afdfbf26d253b0fe0 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Wed, 15 Mar 2023 03:23:41 +0100 Subject: [PATCH 55/93] chore: deprecate the pubsub api Fixes #9717 --- README.md | 3 +-- cmd/ipfs/daemon.go | 2 +- core/commands/pubsub.go | 20 ++++++++++---------- docs/changelogs/v0.19.md | 7 +++++++ docs/config.md | 12 +++++++++++- docs/experimental-features.md | 31 ------------------------------- 6 files changed, 30 insertions(+), 45 deletions(-) diff --git a/README.md b/README.md index e734fef6642..94e5e42af15 100644 --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ Kubo was the first IPFS implementation and is the most widely used one today. Im Featureset - Runs an IPFS-Node as a network service - [Command Line Interface](https://docs.ipfs.tech/reference/kubo/cli/) to IPFS-Nodes -- Local [Web2-to-Web3 HTTP Gateway functionality](https://github.com/ipfs/specs/tree/main/http-gateways#readme) +- Local [Web2-to-Web3 HTTP Gateway functionality](https://github.com/ipfs/specs/tree/main/http-gateways#readme) - HTTP RPC API (`/api/v0`) to access and control the daemon - IPFS's internal Webgui can be used to manage the Kubo nodes @@ -381,7 +381,6 @@ Some places to get you started on the codebase: - libp2p - libp2p: https://github.com/libp2p/go-libp2p - DHT: https://github.com/libp2p/go-libp2p-kad-dht - - PubSub: https://github.com/libp2p/go-libp2p-pubsub - [IPFS : The `Add` command demystified](https://github.com/ipfs/kubo/tree/master/docs/add-code-flow.md) ### Map of Implemented Subsystems diff --git a/cmd/ipfs/daemon.go b/cmd/ipfs/daemon.go index 880d26b0e42..52addcc072c 100644 --- a/cmd/ipfs/daemon.go +++ b/cmd/ipfs/daemon.go @@ -171,7 +171,7 @@ Headers. cmds.BoolOption(enableGCKwd, "Enable automatic periodic repo garbage collection"), cmds.BoolOption(adjustFDLimitKwd, "Check and raise file descriptor limits if needed").WithDefault(true), cmds.BoolOption(migrateKwd, "If true, assume yes at the migrate prompt. If false, assume no."), - cmds.BoolOption(enablePubSubKwd, "Enable experimental pubsub feature. Overrides Pubsub.Enabled config."), + cmds.BoolOption(enablePubSubKwd, "DEPRECATED"), cmds.BoolOption(enableIPNSPubSubKwd, "Enable IPNS over pubsub. Implicitly enables pubsub, overrides Ipns.UsePubsub config."), cmds.BoolOption(enableMultiplexKwd, "DEPRECATED"), cmds.StringOption(agentVersionSuffix, "Optional suffix to the AgentVersion presented by `ipfs id` and also advertised through BitSwap."), diff --git a/core/commands/pubsub.go b/core/commands/pubsub.go index ef8afcb4458..ee795e07829 100644 --- a/core/commands/pubsub.go +++ b/core/commands/pubsub.go @@ -16,14 +16,14 @@ import ( ) var PubsubCmd = &cmds.Command{ - Status: cmds.Experimental, + Status: cmds.Deprecated, Helptext: cmds.HelpText{ Tagline: "An experimental publish-subscribe system on ipfs.", ShortDescription: ` ipfs pubsub allows you to publish messages to a given topic, and also to subscribe to new messages on a given topic. -EXPERIMENTAL FEATURE +DEPRECATED FEATURE (see https://github.com/ipfs/kubo/issues/9717) It is not intended in its current state to be used in a production environment. To use, the daemon must be run with @@ -46,13 +46,13 @@ type pubsubMessage struct { } var PubsubSubCmd = &cmds.Command{ - Status: cmds.Experimental, + Status: cmds.Deprecated, Helptext: cmds.HelpText{ Tagline: "Subscribe to messages on a given topic.", ShortDescription: ` ipfs pubsub sub subscribes to messages on a given topic. -EXPERIMENTAL FEATURE +DEPRECATED FEATURE (see https://github.com/ipfs/kubo/issues/9717) It is not intended in its current state to be used in a production environment. To use, the daemon must be run with @@ -145,14 +145,14 @@ TOPIC AND DATA ENCODING } var PubsubPubCmd = &cmds.Command{ - Status: cmds.Experimental, + Status: cmds.Deprecated, Helptext: cmds.HelpText{ Tagline: "Publish data to a given pubsub topic.", ShortDescription: ` ipfs pubsub pub publishes a message to a specified topic. It reads binary data from stdin or a file. -EXPERIMENTAL FEATURE +DEPRECATED FEATURE (see https://github.com/ipfs/kubo/issues/9717) It is not intended in its current state to be used in a production environment. To use, the daemon must be run with @@ -201,13 +201,13 @@ HTTP RPC ENCODING } var PubsubLsCmd = &cmds.Command{ - Status: cmds.Experimental, + Status: cmds.Deprecated, Helptext: cmds.HelpText{ Tagline: "List subscribed topics by name.", ShortDescription: ` ipfs pubsub ls lists out the names of topics you are currently subscribed to. -EXPERIMENTAL FEATURE +DEPRECATED FEATURE (see https://github.com/ipfs/kubo/issues/9717) It is not intended in its current state to be used in a production environment. To use, the daemon must be run with @@ -273,7 +273,7 @@ func safeTextListEncoder(req *cmds.Request, w io.Writer, list *stringList) error } var PubsubPeersCmd = &cmds.Command{ - Status: cmds.Experimental, + Status: cmds.Deprecated, Helptext: cmds.HelpText{ Tagline: "List peers we are currently pubsubbing with.", ShortDescription: ` @@ -281,7 +281,7 @@ ipfs pubsub peers with no arguments lists out the pubsub peers you are currently connected to. If given a topic, it will list connected peers who are subscribed to the named topic. -EXPERIMENTAL FEATURE +DEPRECATED FEATURE (see https://github.com/ipfs/kubo/issues/9717) It is not intended in its current state to be used in a production environment. To use, the daemon must be run with diff --git a/docs/changelogs/v0.19.md b/docs/changelogs/v0.19.md index fede7a4547f..12331cae78d 100644 --- a/docs/changelogs/v0.19.md +++ b/docs/changelogs/v0.19.md @@ -8,6 +8,7 @@ - [🔦 Highlights](#-highlights) - [Improving the libp2p resource management integration](#improving-the-libp2p-resource-management-integration) - [Addition of "autoclient" router type](#addition-of-autoclient-router-type) + - [Deprecation of the `ipfs pubsub` commands and matching HTTP endpoints](#deprecation-of-the-ipfs-pubsub-commands-and-matching-http-endpoints) - [📝 Changelog](#-changelog) - [👨‍👩‍👧‍👦 Contributors](#-contributors) @@ -28,6 +29,12 @@ A new routing type "autoclient" has been added. This mode is similar to "auto", See the [Routing.Type documentation](https://github.com/ipfs/kubo/blob/master/docs/config.md#routingtype) for more information. +#### Deprecation of the `ipfs pubsub` commands and matching HTTP endpoints + +We are deprecating `ipfs pubsub` and all `/api/v0/pubsub/` RPC endpoints and will remove them in the next release. + +For more information and rational see [#9717](https://github.com/ipfs/kubo/issues/9717). + ### 📝 Changelog ### 👨‍👩‍👧‍👦 Contributors diff --git a/docs/config.md b/docs/config.md index 68666191802..2e9fff51265 100644 --- a/docs/config.md +++ b/docs/config.md @@ -1165,13 +1165,15 @@ Type: `duration` ## `Pubsub` +**DEPRECATED**: See [#9717](https://github.com/ipfs/kubo/issues/9717) + Pubsub configures the `ipfs pubsub` subsystem. To use, it must be enabled by passing the `--enable-pubsub-experiment` flag to the daemon or via the `Pubsub.Enabled` flag below. ### `Pubsub.Enabled` -**EXPERIMENTAL:** read about current limitations at [experimental-features.md#ipfs-pubsub](./experimental-features.md#ipfs-pubsub). +**DEPRECATED**: See [#9717](https://github.com/ipfs/kubo/issues/9717) Enables the pubsub system. @@ -1181,6 +1183,8 @@ Type: `flag` ### `Pubsub.Router` +**DEPRECATED**: See [#9717](https://github.com/ipfs/kubo/issues/9717) + Sets the default router used by pubsub to route messages to peers. This can be one of: * `"floodsub"` - floodsub is a basic router that simply _floods_ messages to all @@ -1196,6 +1200,8 @@ Type: `string` (one of `"floodsub"`, `"gossipsub"`, or `""` (apply default)) ### `Pubsub.DisableSigning` +**DEPRECATED**: See [#9717](https://github.com/ipfs/kubo/issues/9717) + Disables message signing and signature verification. Enable this option if you're operating in a completely trusted network. @@ -1209,6 +1215,8 @@ Type: `bool` ### `Pubsub.SeenMessagesTTL` +**DEPRECATED**: See [#9717](https://github.com/ipfs/kubo/issues/9717) + Controls the time window within which duplicate messages, identified by Message ID, will be identified and won't be emitted again. @@ -1228,6 +1236,8 @@ Type: `optionalDuration` ### `Pubsub.SeenMessagesStrategy` +**DEPRECATED**: See [#9717](https://github.com/ipfs/kubo/issues/9717) + Determines how the time-to-live (TTL) countdown for deduplicating Pubsub messages is calculated. diff --git a/docs/experimental-features.md b/docs/experimental-features.md index 41e72f1df11..296f6ca1e79 100644 --- a/docs/experimental-features.md +++ b/docs/experimental-features.md @@ -12,7 +12,6 @@ When you add a new experimental feature to kubo or change an experimental feature, you MUST please make a PR updating this document, and link the PR in the above issue. -- [ipfs pubsub](#ipfs-pubsub) - [Raw leaves for unixfs files](#raw-leaves-for-unixfs-files) - [ipfs filestore](#ipfs-filestore) - [ipfs urlstore](#ipfs-urlstore) @@ -31,36 +30,6 @@ the above issue. --- -## ipfs pubsub - -### State - -Candidate, disabled by default but will be enabled by default in 0.6.0. - -### In Version - -0.4.5 (`--enable-pubsub-experiment`) -0.11.0 (`Pubsub.Enabled` flag in config) - -### How to enable - -Run your daemon with the `--enable-pubsub-experiment` flag -or modify your ipfs config and restart the daemon: -``` -ipfs config --json Pubsub.Enabled true -``` - -Then use the `ipfs pubsub` commands. - -NOTE: `--enable-pubsub-experiment` CLI flag overrides `Pubsub.Enabled` config. - -Configuration documentation can be found in [kubo/docs/config.md](./config.md#pubsub) - -### Road to being a real feature - -- [ ] Needs to not impact peers who don't use pubsub: - https://github.com/libp2p/go-libp2p-pubsub/issues/332 - ## Raw Leaves for unixfs files Allows files to be added with no formatting in the leaf nodes of the graph. From 684d9dc79fce8d899ea1c5b97a7400526fc1d28f Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Wed, 15 Mar 2023 14:57:23 -0400 Subject: [PATCH 56/93] test: fix flaky rcmgr test --- test/cli/rcmgr_test.go | 6 +++++- test/cli/testutils/asserts.go | 15 +++++++++++++++ 2 files changed, 20 insertions(+), 1 deletion(-) create mode 100644 test/cli/testutils/asserts.go diff --git a/test/cli/rcmgr_test.go b/test/cli/rcmgr_test.go index 51b2b0452e3..9d76a7dd81d 100644 --- a/test/cli/rcmgr_test.go +++ b/test/cli/rcmgr_test.go @@ -7,6 +7,7 @@ import ( "github.com/ipfs/kubo/config" "github.com/ipfs/kubo/core/node/libp2p" "github.com/ipfs/kubo/test/cli/harness" + "github.com/ipfs/kubo/test/cli/testutils" "github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/protocol" rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" @@ -209,7 +210,10 @@ func TestRcmgr(t *testing.T) { Args: []string{"swarm", "connect", node1.SwarmAddrsWithPeerIDs()[0].String()}, }) assert.Equal(t, 1, res.ExitCode()) - assert.Contains(t, res.Stderr.String(), "failed to find any peer in table") + testutils.AssertStringContainsOneOf(t, res.Stderr.String(), + "failed to find any peer in table", + "resource limit exceeded", + ) res = node0.RunIPFS("ping", "-n2", peerID1) assert.Equal(t, 1, res.ExitCode()) diff --git a/test/cli/testutils/asserts.go b/test/cli/testutils/asserts.go new file mode 100644 index 00000000000..cf840c20ee7 --- /dev/null +++ b/test/cli/testutils/asserts.go @@ -0,0 +1,15 @@ +package testutils + +import ( + "strings" + "testing" +) + +func AssertStringContainsOneOf(t *testing.T, str string, ss ...string) { + for _, s := range ss { + if strings.Contains(str, s) { + return + } + } + t.Errorf("%q does not contain one of %v", str, ss) +} From e870dcdc0ec59a8514a0949ce2a8e08eda46667d Mon Sep 17 00:00:00 2001 From: Jorropo Date: Wed, 15 Mar 2023 04:40:16 +0100 Subject: [PATCH 57/93] fix: preserve Unlimited StreamsInbound in connmgr reconciliation Fixes #9695 --- core/node/libp2p/rcmgr.go | 4 ++++ core/node/libp2p/rcmgr_defaults.go | 4 +++- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/core/node/libp2p/rcmgr.go b/core/node/libp2p/rcmgr.go index 54bff2852df..3e162453102 100644 --- a/core/node/libp2p/rcmgr.go +++ b/core/node/libp2p/rcmgr.go @@ -459,6 +459,7 @@ func ensureConnMgrMakeSenseVsResourceMgr(concreteLimits rcmgr.ConcreteLimitConfi return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. resource manager System.Conns (%d) must be bigger than ConnMgr.HighWater (%d) +See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.Conns, highWater) } if rcm.System.ConnsInbound != rcmgr.Unlimited && int64(rcm.System.ConnsInbound) <= highWater { @@ -466,6 +467,7 @@ resource manager System.Conns (%d) must be bigger than ConnMgr.HighWater (%d) return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. resource manager System.ConnsInbound (%d) must be bigger than ConnMgr.HighWater (%d) +See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.ConnsInbound, highWater) } if rcm.System.Streams != rcmgr.Unlimited && int64(rcm.System.Streams) <= highWater { @@ -473,6 +475,7 @@ resource manager System.ConnsInbound (%d) must be bigger than ConnMgr.HighWater return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. resource manager System.Streams (%d) must be bigger than ConnMgr.HighWater (%d) +See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.Streams, highWater) } if rcm.System.StreamsInbound != rcmgr.Unlimited && int64(rcm.System.StreamsInbound) <= highWater { @@ -480,6 +483,7 @@ resource manager System.Streams (%d) must be bigger than ConnMgr.HighWater (%d) return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. resource manager System.StreamsInbound (%d) must be bigger than ConnMgr.HighWater (%d) +See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.StreamsInbound, highWater) } return nil diff --git a/core/node/libp2p/rcmgr_defaults.go b/core/node/libp2p/rcmgr_defaults.go index 5faaf7979b3..4f02c6b4a88 100644 --- a/core/node/libp2p/rcmgr_defaults.go +++ b/core/node/libp2p/rcmgr_defaults.go @@ -129,7 +129,9 @@ func createDefaultLimitConfig(cfg config.SwarmConfig) (limitConfig rcmgr.Concret } // Scale System.StreamsInbound as well, but use the existing ratio of StreamsInbound to ConnsInbound - partialLimits.System.StreamsInbound = rcmgr.LimitVal(maxInboundConns * int64(partialLimits.System.StreamsInbound) / int64(partialLimits.System.ConnsInbound)) + if partialLimits.System.StreamsInbound != rcmgr.Unlimited { + partialLimits.System.StreamsInbound = rcmgr.LimitVal(maxInboundConns * int64(partialLimits.System.StreamsInbound) / int64(partialLimits.System.ConnsInbound)) + } partialLimits.System.ConnsInbound = rcmgr.LimitVal(maxInboundConns) } From 8b05cf05b05f6362756027e266294032b431411a Mon Sep 17 00:00:00 2001 From: Jorropo Date: Wed, 15 Mar 2023 17:36:08 +0100 Subject: [PATCH 58/93] test: add test for presarvation of unlimited configs for inbound systems --- test/cli/rcmgr_test.go | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/test/cli/rcmgr_test.go b/test/cli/rcmgr_test.go index 9d76a7dd81d..3dbceb5d7f7 100644 --- a/test/cli/rcmgr_test.go +++ b/test/cli/rcmgr_test.go @@ -127,6 +127,22 @@ func TestRcmgr(t *testing.T) { }) }) + t.Run("smoke test unlimited System inbounds", func(t *testing.T) { + t.Parallel() + node := harness.NewT(t).NewNode().Init() + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { + overrides.System.StreamsInbound = rcmgr.Unlimited + overrides.System.ConnsInbound = rcmgr.Unlimited + }) + node.StartDaemon() + + res := node.RunIPFS("swarm", "resources", "--enc=json") + limits := unmarshalLimits(t, res.Stdout.Bytes()) + + assert.Equal(t, rcmgr.Unlimited, limits.System.ConnsInbound) + assert.Equal(t, rcmgr.Unlimited, limits.System.StreamsInbound) + }) + t.Run("smoke test transient scope", func(t *testing.T) { t.Parallel() node := harness.NewT(t).NewNode().Init() From a3b417779ca59f6329ae0d713b901537033a0c0a Mon Sep 17 00:00:00 2001 From: Jorropo Date: Wed, 15 Mar 2023 17:40:12 +0100 Subject: [PATCH 59/93] fix: future proof with > rcmgr.DefaultLimit for new enum rcmgr values --- core/node/libp2p/rcmgr.go | 8 ++++---- core/node/libp2p/rcmgr_defaults.go | 4 ++-- test/cli/rcmgr_test.go | 4 ++-- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/core/node/libp2p/rcmgr.go b/core/node/libp2p/rcmgr.go index 3e162453102..c61f8dcfe56 100644 --- a/core/node/libp2p/rcmgr.go +++ b/core/node/libp2p/rcmgr.go @@ -454,7 +454,7 @@ func ensureConnMgrMakeSenseVsResourceMgr(concreteLimits rcmgr.ConcreteLimitConfi rcm := concreteLimits.ToPartialLimitConfig() highWater := cfg.ConnMgr.HighWater.WithDefault(config.DefaultConnMgrHighWater) - if rcm.System.Conns != rcmgr.Unlimited && int64(rcm.System.Conns) <= highWater { + if (rcm.System.Conns > rcmgr.DefaultLimit || rcm.System.Conns == rcmgr.BlockAllLimit) && int64(rcm.System.Conns) <= highWater { // nolint return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. @@ -462,7 +462,7 @@ resource manager System.Conns (%d) must be bigger than ConnMgr.HighWater (%d) See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.Conns, highWater) } - if rcm.System.ConnsInbound != rcmgr.Unlimited && int64(rcm.System.ConnsInbound) <= highWater { + if (rcm.System.ConnsInbound > rcmgr.DefaultLimit || rcm.System.ConnsInbound == rcmgr.BlockAllLimit) && int64(rcm.System.ConnsInbound) <= highWater { // nolint return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. @@ -470,7 +470,7 @@ resource manager System.ConnsInbound (%d) must be bigger than ConnMgr.HighWater See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.ConnsInbound, highWater) } - if rcm.System.Streams != rcmgr.Unlimited && int64(rcm.System.Streams) <= highWater { + if rcm.System.Streams > rcmgr.DefaultLimit || rcm.System.Streams == rcmgr.BlockAllLimit && int64(rcm.System.Streams) <= highWater { // nolint return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. @@ -478,7 +478,7 @@ resource manager System.Streams (%d) must be bigger than ConnMgr.HighWater (%d) See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.Streams, highWater) } - if rcm.System.StreamsInbound != rcmgr.Unlimited && int64(rcm.System.StreamsInbound) <= highWater { + if (rcm.System.StreamsInbound > rcmgr.DefaultLimit || rcm.System.StreamsInbound == rcmgr.BlockAllLimit) && int64(rcm.System.StreamsInbound) <= highWater { // nolint return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. diff --git a/core/node/libp2p/rcmgr_defaults.go b/core/node/libp2p/rcmgr_defaults.go index 4f02c6b4a88..7a0e5a2823d 100644 --- a/core/node/libp2p/rcmgr_defaults.go +++ b/core/node/libp2p/rcmgr_defaults.go @@ -118,7 +118,7 @@ func createDefaultLimitConfig(cfg config.SwarmConfig) (limitConfig rcmgr.Concret // There are ways to break this, but this should catch most problems already. // We might improve this in the future. // See: https://github.com/ipfs/kubo/issues/9545 - if partialLimits.System.ConnsInbound != rcmgr.Unlimited && cfg.ConnMgr.Type.WithDefault(config.DefaultConnMgrType) != "none" { + if partialLimits.System.ConnsInbound > rcmgr.DefaultLimit && cfg.ConnMgr.Type.WithDefault(config.DefaultConnMgrType) != "none" { maxInboundConns := int64(partialLimits.System.ConnsInbound) if connmgrHighWaterTimesTwo := cfg.ConnMgr.HighWater.WithDefault(config.DefaultConnMgrHighWater) * 2; maxInboundConns < connmgrHighWaterTimesTwo { maxInboundConns = connmgrHighWaterTimesTwo @@ -129,7 +129,7 @@ func createDefaultLimitConfig(cfg config.SwarmConfig) (limitConfig rcmgr.Concret } // Scale System.StreamsInbound as well, but use the existing ratio of StreamsInbound to ConnsInbound - if partialLimits.System.StreamsInbound != rcmgr.Unlimited { + if partialLimits.System.StreamsInbound > rcmgr.DefaultLimit { partialLimits.System.StreamsInbound = rcmgr.LimitVal(maxInboundConns * int64(partialLimits.System.StreamsInbound) / int64(partialLimits.System.ConnsInbound)) } partialLimits.System.ConnsInbound = rcmgr.LimitVal(maxInboundConns) diff --git a/test/cli/rcmgr_test.go b/test/cli/rcmgr_test.go index 3dbceb5d7f7..50ea269793d 100644 --- a/test/cli/rcmgr_test.go +++ b/test/cli/rcmgr_test.go @@ -81,10 +81,10 @@ func TestRcmgr(t *testing.T) { require.Equal(t, 0, res.ExitCode()) limits := unmarshalLimits(t, res.Stdout.Bytes()) - if limits.System.ConnsInbound != rcmgr.Unlimited { + if limits.System.ConnsInbound > rcmgr.DefaultLimit { assert.GreaterOrEqual(t, limits.System.ConnsInbound, 800) } - if limits.System.StreamsInbound != rcmgr.Unlimited { + if limits.System.StreamsInbound > rcmgr.DefaultLimit { assert.GreaterOrEqual(t, limits.System.StreamsInbound, 800) } }) From 51eabd46dac6f004cc0301273a2ca6140ecbf7e5 Mon Sep 17 00:00:00 2001 From: Henrique Dias Date: Thu, 16 Mar 2023 17:21:35 +0100 Subject: [PATCH 60/93] chore: bump go-libipfs@v0.6.2 --- docs/examples/kubo-as-a-library/go.mod | 2 +- docs/examples/kubo-as-a-library/go.sum | 4 ++-- go.mod | 2 +- go.sum | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/examples/kubo-as-a-library/go.mod b/docs/examples/kubo-as-a-library/go.mod index 1c19dd3eb94..d96fa795dd1 100644 --- a/docs/examples/kubo-as-a-library/go.mod +++ b/docs/examples/kubo-as-a-library/go.mod @@ -7,7 +7,7 @@ go 1.18 replace github.com/ipfs/kubo => ./../../.. require ( - github.com/ipfs/go-libipfs v0.6.1 + github.com/ipfs/go-libipfs v0.6.2 github.com/ipfs/interface-go-ipfs-core v0.11.0 github.com/ipfs/kubo v0.0.0-00010101000000-000000000000 github.com/libp2p/go-libp2p v0.26.2 diff --git a/docs/examples/kubo-as-a-library/go.sum b/docs/examples/kubo-as-a-library/go.sum index c927b58d90e..3a08f464a97 100644 --- a/docs/examples/kubo-as-a-library/go.sum +++ b/docs/examples/kubo-as-a-library/go.sum @@ -569,8 +569,8 @@ github.com/ipfs/go-ipld-legacy v0.1.1 h1:BvD8PEuqwBHLTKqlGFTHSwrwFOMkVESEvwIYwR2 github.com/ipfs/go-ipld-legacy v0.1.1/go.mod h1:8AyKFCjgRPsQFf15ZQgDB8Din4DML/fOmKZkkFkrIEg= github.com/ipfs/go-ipns v0.3.0 h1:ai791nTgVo+zTuq2bLvEGmWP1M0A6kGTXUsgv/Yq67A= github.com/ipfs/go-ipns v0.3.0/go.mod h1:3cLT2rbvgPZGkHJoPO1YMJeh6LtkxopCkKFcio/wE24= -github.com/ipfs/go-libipfs v0.6.1 h1:OSO9cm1H3r4OXfP0MP1Q5UhTnhd2fByGl6CVYyz/Rhk= -github.com/ipfs/go-libipfs v0.6.1/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= +github.com/ipfs/go-libipfs v0.6.2 h1:QUf3kS3RrCjgtE0QW2d18PFFfOLeEt24Ft892ipLzRI= +github.com/ipfs/go-libipfs v0.6.2/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk= github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A= diff --git a/go.mod b/go.mod index 673dd3793bd..4fce33b56a6 100644 --- a/go.mod +++ b/go.mod @@ -45,7 +45,7 @@ require ( github.com/ipfs/go-ipld-git v0.1.1 github.com/ipfs/go-ipld-legacy v0.1.1 github.com/ipfs/go-ipns v0.3.0 - github.com/ipfs/go-libipfs v0.6.1 + github.com/ipfs/go-libipfs v0.6.2 github.com/ipfs/go-log v1.0.5 github.com/ipfs/go-log/v2 v2.5.1 github.com/ipfs/go-merkledag v0.9.0 diff --git a/go.sum b/go.sum index 16329d6ad3b..100875344fe 100644 --- a/go.sum +++ b/go.sum @@ -591,8 +591,8 @@ github.com/ipfs/go-ipld-legacy v0.1.1 h1:BvD8PEuqwBHLTKqlGFTHSwrwFOMkVESEvwIYwR2 github.com/ipfs/go-ipld-legacy v0.1.1/go.mod h1:8AyKFCjgRPsQFf15ZQgDB8Din4DML/fOmKZkkFkrIEg= github.com/ipfs/go-ipns v0.3.0 h1:ai791nTgVo+zTuq2bLvEGmWP1M0A6kGTXUsgv/Yq67A= github.com/ipfs/go-ipns v0.3.0/go.mod h1:3cLT2rbvgPZGkHJoPO1YMJeh6LtkxopCkKFcio/wE24= -github.com/ipfs/go-libipfs v0.6.1 h1:OSO9cm1H3r4OXfP0MP1Q5UhTnhd2fByGl6CVYyz/Rhk= -github.com/ipfs/go-libipfs v0.6.1/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= +github.com/ipfs/go-libipfs v0.6.2 h1:QUf3kS3RrCjgtE0QW2d18PFFfOLeEt24Ft892ipLzRI= +github.com/ipfs/go-libipfs v0.6.2/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk= github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A= From 23b5abfb7abcf5775640e72df327fc25f06482ac Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Thu, 16 Mar 2023 08:41:50 -0400 Subject: [PATCH 61/93] feat: add heap allocs to 'ipfs diag profile' --- core/commands/profile.go | 4 +++- profile/profile.go | 10 ++++++++++ profile/profile_test.go | 6 ++++++ 3 files changed, 19 insertions(+), 1 deletion(-) diff --git a/core/commands/profile.go b/core/commands/profile.go index 3875cfdcba2..d25711dac22 100644 --- a/core/commands/profile.go +++ b/core/commands/profile.go @@ -49,7 +49,8 @@ The output file includes: - A list of running goroutines. - A CPU profile. -- A heap profile. +- A heap inuse profile. +- A heap allocation profile. - A mutex profile. - A block profile. - Your copy of go-ipfs. @@ -79,6 +80,7 @@ However, it could reveal: profile.CollectorGoroutinesPprof, profile.CollectorVersion, profile.CollectorHeap, + profile.CollectorAllocs, profile.CollectorBin, profile.CollectorCPU, profile.CollectorMutex, diff --git a/profile/profile.go b/profile/profile.go index d15d5125140..b9ad86d2f53 100644 --- a/profile/profile.go +++ b/profile/profile.go @@ -22,6 +22,7 @@ const ( CollectorGoroutinesPprof = "goroutines-pprof" CollectorVersion = "version" CollectorHeap = "heap" + CollectorAllocs = "allocs" CollectorBin = "bin" CollectorCPU = "cpu" CollectorMutex = "mutex" @@ -71,6 +72,11 @@ var collectors = map[string]collector{ collectFunc: heapProfile, enabledFunc: func(opts Options) bool { return true }, }, + CollectorAllocs: { + outputFile: "allocs.pprof", + collectFunc: allocsProfile, + enabledFunc: func(opts Options) bool { return true }, + }, CollectorBin: { outputFile: "ipfs", isExecutable: true, @@ -197,6 +203,10 @@ func heapProfile(ctx context.Context, _ Options, w io.Writer) error { return pprof.Lookup("heap").WriteTo(w, 0) } +func allocsProfile(ctx context.Context, _ Options, w io.Writer) error { + return pprof.Lookup("allocs").WriteTo(w, 0) +} + func versionInfo(ctx context.Context, _ Options, w io.Writer) error { return json.NewEncoder(w).Encode(version.GetVersionInfo()) } diff --git a/profile/profile_test.go b/profile/profile_test.go index 8da00d0181a..a2fe0b51d59 100644 --- a/profile/profile_test.go +++ b/profile/profile_test.go @@ -17,6 +17,7 @@ func TestProfiler(t *testing.T) { CollectorGoroutinesPprof, CollectorVersion, CollectorHeap, + CollectorAllocs, CollectorBin, CollectorCPU, CollectorMutex, @@ -43,6 +44,7 @@ func TestProfiler(t *testing.T) { "goroutines.pprof", "version.json", "heap.pprof", + "allocs.pprof", "ipfs", "cpu.pprof", "mutex.pprof", @@ -63,6 +65,7 @@ func TestProfiler(t *testing.T) { "goroutines.pprof", "version.json", "heap.pprof", + "allocs.pprof", "ipfs.exe", "cpu.pprof", "mutex.pprof", @@ -81,6 +84,7 @@ func TestProfiler(t *testing.T) { "goroutines.pprof", "version.json", "heap.pprof", + "allocs.pprof", "ipfs", }, }, @@ -96,6 +100,7 @@ func TestProfiler(t *testing.T) { "goroutines.pprof", "version.json", "heap.pprof", + "allocs.pprof", "ipfs", "cpu.pprof", "block.pprof", @@ -114,6 +119,7 @@ func TestProfiler(t *testing.T) { "goroutines.pprof", "version.json", "heap.pprof", + "allocs.pprof", "ipfs", "cpu.pprof", "mutex.pprof", From 63b2a0e069e4e37b0c1c36a73a3d62b452b2c7a5 Mon Sep 17 00:00:00 2001 From: Henrique Dias Date: Fri, 17 Mar 2023 15:14:10 +0100 Subject: [PATCH 62/93] fix: apply API.HTTPHeaders to /webui redirect --- core/corehttp/redirect.go | 15 +++++++++++++-- test/cli/gateway_test.go | 17 +++++++++++++++++ 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/core/corehttp/redirect.go b/core/corehttp/redirect.go index bcd536d235b..4b98963e2b7 100644 --- a/core/corehttp/redirect.go +++ b/core/corehttp/redirect.go @@ -8,8 +8,14 @@ import ( ) func RedirectOption(path string, redirect string) ServeOption { - handler := &redirectHandler{redirect} return func(n *core.IpfsNode, _ net.Listener, mux *http.ServeMux) (*http.ServeMux, error) { + cfg, err := n.Repo.Config() + if err != nil { + return nil, err + } + + handler := &redirectHandler{redirect, cfg.API.HTTPHeaders} + if len(path) > 0 { mux.Handle("/"+path+"/", handler) } else { @@ -20,9 +26,14 @@ func RedirectOption(path string, redirect string) ServeOption { } type redirectHandler struct { - path string + path string + headers map[string][]string } func (i *redirectHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { + for k, v := range i.headers { + w.Header()[k] = v + } + http.Redirect(w, r, i.path, http.StatusFound) } diff --git a/test/cli/gateway_test.go b/test/cli/gateway_test.go index a585925a763..d2a90b04ae4 100644 --- a/test/cli/gateway_test.go +++ b/test/cli/gateway_test.go @@ -219,6 +219,23 @@ func TestGateway(t *testing.T) { assert.Contains(t, []int{302, 301}, resp.StatusCode) }) + t.Run("GET /webui/ returns user-specified headers", func(t *testing.T) { + t.Parallel() + + header := "Access-Control-Allow-Origin" + values := []string{"http://localhost:3000", "https://webui.ipfs.io"} + + node := harness.NewT(t).NewNode().Init() + node.UpdateConfig(func(cfg *config.Config) { + cfg.API.HTTPHeaders = map[string][]string{header: values} + }) + node.StartDaemon() + + resp := node.APIClient().DisableRedirects().Get("/webui/") + assert.Equal(t, resp.Headers.Values(header), values) + assert.Contains(t, []int{302, 301}, resp.StatusCode) + }) + t.Run("GET /logs returns logs", func(t *testing.T) { t.Parallel() apiClient := node.APIClient() From ed671e84891232c99165c4759b046ce303a30b49 Mon Sep 17 00:00:00 2001 From: Henrique Dias Date: Fri, 17 Mar 2023 15:29:39 +0100 Subject: [PATCH 63/93] fix: canonicalize user defined headers --- core/corehttp/gateway_writable.go | 2 +- core/corehttp/redirect.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/core/corehttp/gateway_writable.go b/core/corehttp/gateway_writable.go index 89a2973ac23..34cd8438ea7 100644 --- a/core/corehttp/gateway_writable.go +++ b/core/corehttp/gateway_writable.go @@ -30,7 +30,7 @@ type writableGatewayHandler struct { func (i *writableGatewayHandler) addUserHeaders(w http.ResponseWriter) { for k, v := range i.config.Headers { - w.Header()[k] = v + w.Header()[http.CanonicalHeaderKey(k)] = v } } diff --git a/core/corehttp/redirect.go b/core/corehttp/redirect.go index 4b98963e2b7..106355d247d 100644 --- a/core/corehttp/redirect.go +++ b/core/corehttp/redirect.go @@ -32,7 +32,7 @@ type redirectHandler struct { func (i *redirectHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { for k, v := range i.headers { - w.Header()[k] = v + w.Header()[http.CanonicalHeaderKey(k)] = v } http.Redirect(w, r, i.path, http.StatusFound) From 715019440f6d122e1d949615359c6a79548cf5e4 Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Mon, 20 Mar 2023 09:47:59 +0100 Subject: [PATCH 64/93] chore: update go-libp2p to v0.26.3 (#9737) --- docs/examples/kubo-as-a-library/go.mod | 2 +- docs/examples/kubo-as-a-library/go.sum | 4 ++-- go.mod | 2 +- go.sum | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/examples/kubo-as-a-library/go.mod b/docs/examples/kubo-as-a-library/go.mod index d96fa795dd1..5453ae1d581 100644 --- a/docs/examples/kubo-as-a-library/go.mod +++ b/docs/examples/kubo-as-a-library/go.mod @@ -10,7 +10,7 @@ require ( github.com/ipfs/go-libipfs v0.6.2 github.com/ipfs/interface-go-ipfs-core v0.11.0 github.com/ipfs/kubo v0.0.0-00010101000000-000000000000 - github.com/libp2p/go-libp2p v0.26.2 + github.com/libp2p/go-libp2p v0.26.3 github.com/multiformats/go-multiaddr v0.8.0 ) diff --git a/docs/examples/kubo-as-a-library/go.sum b/docs/examples/kubo-as-a-library/go.sum index 3a08f464a97..6f7e7f253b3 100644 --- a/docs/examples/kubo-as-a-library/go.sum +++ b/docs/examples/kubo-as-a-library/go.sum @@ -730,8 +730,8 @@ github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xS github.com/libp2p/go-libp2p v0.7.4/go.mod h1:oXsBlTLF1q7pxr+9w6lqzS1ILpyHsaBPniVO7zIHGMw= github.com/libp2p/go-libp2p v0.8.1/go.mod h1:QRNH9pwdbEBpx5DTJYg+qxcVaDMAz3Ee/qDKwXujH5o= github.com/libp2p/go-libp2p v0.14.3/go.mod h1:d12V4PdKbpL0T1/gsUNN8DfgMuRPDX8bS2QxCZlwRH0= -github.com/libp2p/go-libp2p v0.26.2 h1:eHEoW/696FP7/6DxOvcrKfTD6Bi0DExxiMSZUJxswA0= -github.com/libp2p/go-libp2p v0.26.2/go.mod h1:x75BN32YbwuY0Awm2Uix4d4KOz+/4piInkp4Wr3yOo8= +github.com/libp2p/go-libp2p v0.26.3 h1:6g/psubqwdaBqNNoidbRKSTBEYgaOuKBhHl8Q5tO+PM= +github.com/libp2p/go-libp2p v0.26.3/go.mod h1:x75BN32YbwuY0Awm2Uix4d4KOz+/4piInkp4Wr3yOo8= github.com/libp2p/go-libp2p-asn-util v0.3.0 h1:gMDcMyYiZKkocGXDQ5nsUQyquC9+H+iLEQHwOCZ7s8s= github.com/libp2p/go-libp2p-asn-util v0.3.0/go.mod h1:B1mcOrKUE35Xq/ASTmQ4tN3LNzVVaMNmq2NACuqyB9w= github.com/libp2p/go-libp2p-autonat v0.1.0/go.mod h1:1tLf2yXxiE/oKGtDwPYWTSYG3PtvYlJmg7NeVtPRqH8= diff --git a/go.mod b/go.mod index 4fce33b56a6..f7237b46a74 100644 --- a/go.mod +++ b/go.mod @@ -67,7 +67,7 @@ require ( github.com/jbenet/go-temp-err-catcher v0.1.0 github.com/jbenet/goprocess v0.1.4 github.com/libp2p/go-doh-resolver v0.4.0 - github.com/libp2p/go-libp2p v0.26.2 + github.com/libp2p/go-libp2p v0.26.3 github.com/libp2p/go-libp2p-http v0.4.0 github.com/libp2p/go-libp2p-kad-dht v0.21.1 github.com/libp2p/go-libp2p-kbucket v0.5.0 diff --git a/go.sum b/go.sum index 100875344fe..27e101e1c8a 100644 --- a/go.sum +++ b/go.sum @@ -760,8 +760,8 @@ github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xS github.com/libp2p/go-libp2p v0.7.4/go.mod h1:oXsBlTLF1q7pxr+9w6lqzS1ILpyHsaBPniVO7zIHGMw= github.com/libp2p/go-libp2p v0.8.1/go.mod h1:QRNH9pwdbEBpx5DTJYg+qxcVaDMAz3Ee/qDKwXujH5o= github.com/libp2p/go-libp2p v0.14.3/go.mod h1:d12V4PdKbpL0T1/gsUNN8DfgMuRPDX8bS2QxCZlwRH0= -github.com/libp2p/go-libp2p v0.26.2 h1:eHEoW/696FP7/6DxOvcrKfTD6Bi0DExxiMSZUJxswA0= -github.com/libp2p/go-libp2p v0.26.2/go.mod h1:x75BN32YbwuY0Awm2Uix4d4KOz+/4piInkp4Wr3yOo8= +github.com/libp2p/go-libp2p v0.26.3 h1:6g/psubqwdaBqNNoidbRKSTBEYgaOuKBhHl8Q5tO+PM= +github.com/libp2p/go-libp2p v0.26.3/go.mod h1:x75BN32YbwuY0Awm2Uix4d4KOz+/4piInkp4Wr3yOo8= github.com/libp2p/go-libp2p-asn-util v0.2.0 h1:rg3+Os8jbnO5DxkC7K/Utdi+DkY3q/d1/1q+8WeNAsw= github.com/libp2p/go-libp2p-asn-util v0.2.0/go.mod h1:WoaWxbHKBymSN41hWSq/lGKJEca7TNm58+gGJi2WsLI= github.com/libp2p/go-libp2p-autonat v0.1.0/go.mod h1:1tLf2yXxiE/oKGtDwPYWTSYG3PtvYlJmg7NeVtPRqH8= From adcee3e515b231632249d397cb2e866e06d6ddc4 Mon Sep 17 00:00:00 2001 From: Will Hawkins Date: Mon, 14 Nov 2022 14:17:04 +0000 Subject: [PATCH 65/93] fix: typo in documentation for install path By default, `go install` will install go $GOBIN and not $GOPATH/bin. In most cases there is no functional difference -- `go install` falls back to $GOPATH/bin when $GOBIN is empty. --- Rules.mk | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Rules.mk b/Rules.mk index f7e962549c8..3d3d9c13951 100644 --- a/Rules.mk +++ b/Rules.mk @@ -118,7 +118,7 @@ help: @echo ' all - print this help message' @echo ' build - Build binary at ./cmd/ipfs/ipfs' @echo ' nofuse - Build binary with no fuse support' - @echo ' install - Build binary and install into $$GOPATH/bin' + @echo ' install - Build binary and install into $$GOBIN' # @echo ' dist_install - TODO: c.f. ./cmd/ipfs/dist/README.md' @echo '' @echo 'CLEANING TARGETS:' From c30ab94c53eed391a841f8a1e6f83e22c8fcc655 Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Mon, 6 Mar 2023 20:03:19 +0100 Subject: [PATCH 66/93] Merge pull request #9689 from ipfs/no-testground ci: remove disabled testground workflow --- .github/workflows/testground-on-push.yml | 38 ------------------------ 1 file changed, 38 deletions(-) delete mode 100644 .github/workflows/testground-on-push.yml diff --git a/.github/workflows/testground-on-push.yml b/.github/workflows/testground-on-push.yml deleted file mode 100644 index 7b55dbdee3b..00000000000 --- a/.github/workflows/testground-on-push.yml +++ /dev/null @@ -1,38 +0,0 @@ ---- -name: Testground PR Checker - -on: - workflow_dispatch: - push: - - -jobs: - testground: - if: github.repository == 'ipfs/kubo' || github.event_name == 'workflow_dispatch' - runs-on: ubuntu-latest - name: ${{ matrix.composition_file }} - strategy: - matrix: - include: - - backend_addr: ci.testground.ipfs.team - backend_proto: https - plan_directory: testplans/bitswap - composition_file: testplans/bitswap/_compositions/small-k8s.toml - - backend_addr: ci.testground.ipfs.team - backend_proto: https - plan_directory: testplans/bitswap - composition_file: testplans/bitswap/_compositions/medium-k8s.toml - - backend_addr: ci.testground.ipfs.team - backend_proto: https - plan_directory: testplans/bitswap - composition_file: testplans/bitswap/_compositions/large-k8s.toml - steps: - - uses: actions/checkout@v2 - - name: testground run - uses: testground/testground-github-action@v1 - timeout-minutes: 5 - with: - backend_addr: ${{ matrix.backend_addr }} - backend_proto: ${{ matrix.backend_proto }} - plan_directory: ${{ matrix.plan_directory }} - composition_file: ${{ matrix.composition_file }} From ff019366f5c7335656e33c5dc985dd68bd21db61 Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Mon, 6 Mar 2023 20:19:34 +0100 Subject: [PATCH 67/93] Merge pull request #9699 from ipfs/early-testers docs: add bifrost to early testers --- docs/EARLY_TESTERS.md | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/docs/EARLY_TESTERS.md b/docs/EARLY_TESTERS.md index fb2fedc2a33..d0dd4a8672e 100644 --- a/docs/EARLY_TESTERS.md +++ b/docs/EARLY_TESTERS.md @@ -22,15 +22,16 @@ We will ask early testers to participate at two points in the process: ## Who has signed up? -- [ ] pacman.store (@RubenKelevra) +- [ ] Charity Engine (@rytiss, @tristanolive) +- [ ] Fission (@bmann) - [ ] Infura (@MichaelMure) -- [ ] Textile (@sanderpick) +- [ ] OrbitDB (@aphelionz) +- [ ] pacman.store (@RubenKelevra) - [ ] Pinata (@obo20) +- [ ] PL EngRes bifrost (@gmasgras) - [ ] RTrade (@postables) - [ ] Siderus (@koalalorenzo) -- [ ] Charity Engine (@rytiss, @tristanolive) -- [ ] Fission (@bmann) -- [ ] OrbitDB (@aphelionz) +- [ ] Textile (@sanderpick) ## How to sign up? From 8fe7d779c1b977bebc20e549a8c5227f436673d6 Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Wed, 8 Mar 2023 10:19:28 +0100 Subject: [PATCH 68/93] Merge pull request #9696 from ipfs/galargh-patch-2 fix: t0116-gateway-cache.sh --- test/sharness/t0116-gateway-cache.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/sharness/t0116-gateway-cache.sh b/test/sharness/t0116-gateway-cache.sh index 508fc73c288..0cb1a94eb00 100755 --- a/test/sharness/t0116-gateway-cache.sh +++ b/test/sharness/t0116-gateway-cache.sh @@ -204,7 +204,7 @@ test_expect_success "Prepare IPNS unixfs content path for testing" ' grep -E "< Etag: \"DirIndex-.+_CID-${ROOT3_CID}\"" curl_ipfs_dir_listing_output ' test_expect_success "GET /ipns/ dir response has special Etag for generated dir listing" ' - test_should_contain "< Etag: \"DirIndex" curl_ipfs_dir_listing_output && + test_should_contain "< Etag: \"DirIndex" curl_ipns_dir_listing_output && grep -E "< Etag: \"DirIndex-.+_CID-${ROOT3_CID}\"" curl_ipns_dir_listing_output ' From d339059a7fb44467b8d3bb92359236cf76538c91 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Tue, 7 Mar 2023 19:28:52 +0100 Subject: [PATCH 69/93] chore: bump go-libipfs v0.6.1 This does nothing, just move from an untagged commit to a tagged commit but contain the same things. --- docs/examples/kubo-as-a-library/go.mod | 2 +- docs/examples/kubo-as-a-library/go.sum | 4 ++-- go.mod | 2 +- go.sum | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/examples/kubo-as-a-library/go.mod b/docs/examples/kubo-as-a-library/go.mod index 056aea33467..1c19dd3eb94 100644 --- a/docs/examples/kubo-as-a-library/go.mod +++ b/docs/examples/kubo-as-a-library/go.mod @@ -7,7 +7,7 @@ go 1.18 replace github.com/ipfs/kubo => ./../../.. require ( - github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 + github.com/ipfs/go-libipfs v0.6.1 github.com/ipfs/interface-go-ipfs-core v0.11.0 github.com/ipfs/kubo v0.0.0-00010101000000-000000000000 github.com/libp2p/go-libp2p v0.26.2 diff --git a/docs/examples/kubo-as-a-library/go.sum b/docs/examples/kubo-as-a-library/go.sum index 8a07bfbe87a..c927b58d90e 100644 --- a/docs/examples/kubo-as-a-library/go.sum +++ b/docs/examples/kubo-as-a-library/go.sum @@ -569,8 +569,8 @@ github.com/ipfs/go-ipld-legacy v0.1.1 h1:BvD8PEuqwBHLTKqlGFTHSwrwFOMkVESEvwIYwR2 github.com/ipfs/go-ipld-legacy v0.1.1/go.mod h1:8AyKFCjgRPsQFf15ZQgDB8Din4DML/fOmKZkkFkrIEg= github.com/ipfs/go-ipns v0.3.0 h1:ai791nTgVo+zTuq2bLvEGmWP1M0A6kGTXUsgv/Yq67A= github.com/ipfs/go-ipns v0.3.0/go.mod h1:3cLT2rbvgPZGkHJoPO1YMJeh6LtkxopCkKFcio/wE24= -github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 h1:QRLcCoITO9ZQo2pvjmrfngqKhUKjPopBva3MVH62LT8= -github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260/go.mod h1:3OoEQs95UkqFEf65SbRDpiMwuzI+C/jTsYQaHfBbJXI= +github.com/ipfs/go-libipfs v0.6.1 h1:OSO9cm1H3r4OXfP0MP1Q5UhTnhd2fByGl6CVYyz/Rhk= +github.com/ipfs/go-libipfs v0.6.1/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk= github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A= diff --git a/go.mod b/go.mod index 34603ebd2d4..673dd3793bd 100644 --- a/go.mod +++ b/go.mod @@ -45,7 +45,7 @@ require ( github.com/ipfs/go-ipld-git v0.1.1 github.com/ipfs/go-ipld-legacy v0.1.1 github.com/ipfs/go-ipns v0.3.0 - github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 + github.com/ipfs/go-libipfs v0.6.1 github.com/ipfs/go-log v1.0.5 github.com/ipfs/go-log/v2 v2.5.1 github.com/ipfs/go-merkledag v0.9.0 diff --git a/go.sum b/go.sum index 6f7800a2e2a..16329d6ad3b 100644 --- a/go.sum +++ b/go.sum @@ -591,8 +591,8 @@ github.com/ipfs/go-ipld-legacy v0.1.1 h1:BvD8PEuqwBHLTKqlGFTHSwrwFOMkVESEvwIYwR2 github.com/ipfs/go-ipld-legacy v0.1.1/go.mod h1:8AyKFCjgRPsQFf15ZQgDB8Din4DML/fOmKZkkFkrIEg= github.com/ipfs/go-ipns v0.3.0 h1:ai791nTgVo+zTuq2bLvEGmWP1M0A6kGTXUsgv/Yq67A= github.com/ipfs/go-ipns v0.3.0/go.mod h1:3cLT2rbvgPZGkHJoPO1YMJeh6LtkxopCkKFcio/wE24= -github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260 h1:QRLcCoITO9ZQo2pvjmrfngqKhUKjPopBva3MVH62LT8= -github.com/ipfs/go-libipfs v0.6.1-0.20230228004237-36918f45f260/go.mod h1:3OoEQs95UkqFEf65SbRDpiMwuzI+C/jTsYQaHfBbJXI= +github.com/ipfs/go-libipfs v0.6.1 h1:OSO9cm1H3r4OXfP0MP1Q5UhTnhd2fByGl6CVYyz/Rhk= +github.com/ipfs/go-libipfs v0.6.1/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk= github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A= From bfa425fc67b5a6125412cd2453d6fa7f83a4bc96 Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Wed, 8 Mar 2023 15:48:56 -0500 Subject: [PATCH 70/93] test: port legacy DHT tests to Go --- test/cli/dht_legacy_test.go | 137 ++++++++++++++++++++++++++++++ test/cli/harness/harness.go | 2 +- test/cli/harness/node.go | 44 +++++++--- test/cli/harness/nodes.go | 16 ++++ test/cli/harness/run.go | 8 +- test/sharness/t0170-legacy-dht.sh | 121 -------------------------- 6 files changed, 192 insertions(+), 136 deletions(-) create mode 100644 test/cli/dht_legacy_test.go delete mode 100755 test/sharness/t0170-legacy-dht.sh diff --git a/test/cli/dht_legacy_test.go b/test/cli/dht_legacy_test.go new file mode 100644 index 00000000000..437b62ae4ea --- /dev/null +++ b/test/cli/dht_legacy_test.go @@ -0,0 +1,137 @@ +package cli + +import ( + "sort" + "sync" + "testing" + + "github.com/ipfs/kubo/test/cli/harness" + "github.com/ipfs/kubo/test/cli/testutils" + "github.com/libp2p/go-libp2p/core/peer" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestLegacyDHT(t *testing.T) { + nodes := harness.NewT(t).NewNodes(5).Init() + nodes.ForEachPar(func(node *harness.Node) { + node.IPFS("config", "Routing.Type", "dht") + }) + nodes.StartDaemons().Connect() + + t.Run("ipfs dht findpeer", func(t *testing.T) { + t.Parallel() + res := nodes[1].RunIPFS("dht", "findpeer", nodes[0].PeerID().String()) + assert.Equal(t, 0, res.ExitCode()) + + swarmAddr := nodes[0].SwarmAddrsWithoutPeerIDs()[0] + require.Equal(t, swarmAddr.String(), res.Stdout.Trimmed()) + }) + + t.Run("ipfs dht get ", func(t *testing.T) { + t.Parallel() + hash := nodes[2].IPFSAddStr("hello world") + nodes[2].IPFS("name", "publish", "/ipfs/"+hash) + + res := nodes[1].IPFS("dht", "get", "/ipns/"+nodes[2].PeerID().String()) + assert.Contains(t, res.Stdout.String(), "/ipfs/"+hash) + + t.Run("put round trips (#3124)", func(t *testing.T) { + t.Parallel() + nodes[0].WriteBytes("get_result", res.Stdout.Bytes()) + res := nodes[0].IPFS("dht", "put", "/ipns/"+nodes[2].PeerID().String(), "get_result") + assert.Greater(t, len(res.Stdout.Lines()), 0, "should put to at least one node") + }) + + t.Run("put with bad keys fails (issue #5113, #4611)", func(t *testing.T) { + t.Parallel() + keys := []string{"foo", "/pk/foo", "/ipns/foo"} + for _, key := range keys { + key := key + t.Run(key, func(t *testing.T) { + t.Parallel() + res := nodes[0].RunIPFS("dht", "put", key) + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "invalid") + assert.Empty(t, res.Stdout.String()) + }) + } + }) + + t.Run("get with bad keys (issue #4611)", func(t *testing.T) { + for _, key := range []string{"foo", "/pk/foo"} { + key := key + t.Run(key, func(t *testing.T) { + t.Parallel() + res := nodes[0].RunIPFS("dht", "get", key) + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "invalid") + assert.Empty(t, res.Stdout.String()) + }) + } + }) + }) + + t.Run("ipfs dht findprovs", func(t *testing.T) { + t.Parallel() + hash := nodes[3].IPFSAddStr("some stuff") + res := nodes[4].IPFS("dht", "findprovs", hash) + assert.Equal(t, nodes[3].PeerID().String(), res.Stdout.Trimmed()) + }) + + t.Run("ipfs dht query ", func(t *testing.T) { + t.Parallel() + t.Run("normal DHT configuration", func(t *testing.T) { + t.Parallel() + hash := nodes[0].IPFSAddStr("some other stuff") + peerCounts := map[string]int{} + peerCountsMut := sync.Mutex{} + harness.Nodes(nodes).ForEachPar(func(node *harness.Node) { + res := node.IPFS("dht", "query", hash) + closestPeer := res.Stdout.Lines()[0] + // check that it's a valid peer ID + _, err := peer.Decode(closestPeer) + require.NoError(t, err) + + peerCountsMut.Lock() + peerCounts[closestPeer]++ + peerCountsMut.Unlock() + }) + // 4 nodes should see the same peer ID + // 1 node (the closest) should see a different one + var counts []int + for _, count := range peerCounts { + counts = append(counts, count) + } + sort.IntSlice(counts).Sort() + assert.Equal(t, []int{1, 4}, counts) + }) + + }) + + t.Run("dht commands fail when offline", func(t *testing.T) { + t.Parallel() + node := harness.NewT(t).NewNode().Init() + + // these cannot be run in parallel due to repo locking (seems like a bug) + + t.Run("dht findprovs", func(t *testing.T) { + res := node.RunIPFS("dht", "findprovs", testutils.CIDEmptyDir) + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "this command must be run in online mode") + }) + + t.Run("dht findpeer", func(t *testing.T) { + res := node.RunIPFS("dht", "findpeer", testutils.CIDEmptyDir) + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "this command must be run in online mode") + }) + + t.Run("dht put", func(t *testing.T) { + node.WriteBytes("foo", []byte("foo")) + res := node.RunIPFS("dht", "put", "/ipns/"+node.PeerID().String(), "foo") + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "this action must be run in online mode") + }) + }) +} diff --git a/test/cli/harness/harness.go b/test/cli/harness/harness.go index de962e1c120..a35fead3512 100644 --- a/test/cli/harness/harness.go +++ b/test/cli/harness/harness.go @@ -171,7 +171,7 @@ func (h *Harness) Mkdirs(paths ...string) { } } -func (h *Harness) Sh(expr string) RunResult { +func (h *Harness) Sh(expr string) *RunResult { return h.Runner.Run(RunRequest{ Path: "bash", Args: []string{"-c", expr}, diff --git a/test/cli/harness/node.go b/test/cli/harness/node.go index 0d0295307ff..181fca99bc4 100644 --- a/test/cli/harness/node.go +++ b/test/cli/harness/node.go @@ -129,23 +129,23 @@ func (n *Node) UpdateConfigAndUserSuppliedResourceManagerOverrides(f func(cfg *c n.WriteUserSuppliedResourceOverrides(overrides) } -func (n *Node) IPFS(args ...string) RunResult { +func (n *Node) IPFS(args ...string) *RunResult { res := n.RunIPFS(args...) n.Runner.AssertNoError(res) return res } -func (n *Node) PipeStrToIPFS(s string, args ...string) RunResult { +func (n *Node) PipeStrToIPFS(s string, args ...string) *RunResult { return n.PipeToIPFS(strings.NewReader(s), args...) } -func (n *Node) PipeToIPFS(reader io.Reader, args ...string) RunResult { +func (n *Node) PipeToIPFS(reader io.Reader, args ...string) *RunResult { res := n.RunPipeToIPFS(reader, args...) n.Runner.AssertNoError(res) return res } -func (n *Node) RunPipeToIPFS(reader io.Reader, args ...string) RunResult { +func (n *Node) RunPipeToIPFS(reader io.Reader, args ...string) *RunResult { return n.Runner.Run(RunRequest{ Path: n.IPFSBin, Args: args, @@ -153,7 +153,7 @@ func (n *Node) RunPipeToIPFS(reader io.Reader, args ...string) RunResult { }) } -func (n *Node) RunIPFS(args ...string) RunResult { +func (n *Node) RunIPFS(args ...string) *RunResult { return n.Runner.Run(RunRequest{ Path: n.IPFSBin, Args: args, @@ -216,7 +216,7 @@ func (n *Node) StartDaemon(ipfsArgs ...string) *Node { RunFunc: (*exec.Cmd).Start, }) - n.Daemon = &res + n.Daemon = res log.Debugf("node %d started, checking API", n.ID) n.WaitOnAPI() @@ -399,8 +399,6 @@ func (n *Node) SwarmAddrs() []multiaddr.Multiaddr { Path: n.IPFSBin, Args: []string{"swarm", "addrs", "local"}, }) - ipfsProtocol := multiaddr.ProtocolWithCode(multiaddr.P_IPFS).Name - peerID := n.PeerID() out := strings.TrimSpace(res.Stdout.String()) outLines := strings.Split(out, "\n") var addrs []multiaddr.Multiaddr @@ -409,9 +407,18 @@ func (n *Node) SwarmAddrs() []multiaddr.Multiaddr { if err != nil { panic(err) } + addrs = append(addrs, ma) + } + return addrs +} +func (n *Node) SwarmAddrsWithPeerIDs() []multiaddr.Multiaddr { + ipfsProtocol := multiaddr.ProtocolWithCode(multiaddr.P_IPFS).Name + peerID := n.PeerID() + var addrs []multiaddr.Multiaddr + for _, ma := range n.SwarmAddrs() { // add the peer ID to the multiaddr if it doesn't have it - _, err = ma.ValueForProtocol(multiaddr.P_IPFS) + _, err := ma.ValueForProtocol(multiaddr.P_IPFS) if errors.Is(err, multiaddr.ErrProtocolNotFound) { comp, err := multiaddr.NewComponent(ipfsProtocol, peerID.String()) if err != nil { @@ -424,10 +431,27 @@ func (n *Node) SwarmAddrs() []multiaddr.Multiaddr { return addrs } +func (n *Node) SwarmAddrsWithoutPeerIDs() []multiaddr.Multiaddr { + var addrs []multiaddr.Multiaddr + for _, ma := range n.SwarmAddrs() { + var components []multiaddr.Multiaddr + multiaddr.ForEach(ma, func(c multiaddr.Component) bool { + if c.Protocol().Code == multiaddr.P_IPFS { + return true + } + components = append(components, &c) + return true + }) + ma = multiaddr.Join(components...) + addrs = append(addrs, ma) + } + return addrs +} + func (n *Node) Connect(other *Node) *Node { n.Runner.MustRun(RunRequest{ Path: n.IPFSBin, - Args: []string{"swarm", "connect", other.SwarmAddrs()[0].String()}, + Args: []string{"swarm", "connect", other.SwarmAddrsWithPeerIDs()[0].String()}, }) return n } diff --git a/test/cli/harness/nodes.go b/test/cli/harness/nodes.go index dbc7de16ba1..872d7767913 100644 --- a/test/cli/harness/nodes.go +++ b/test/cli/harness/nodes.go @@ -4,6 +4,7 @@ import ( "sync" "github.com/multiformats/go-multiaddr" + "golang.org/x/sync/errgroup" ) // Nodes is a collection of Kubo nodes along with operations on groups of nodes. @@ -16,6 +17,21 @@ func (n Nodes) Init(args ...string) Nodes { return n } +func (n Nodes) ForEachPar(f func(*Node)) { + group := &errgroup.Group{} + for _, node := range n { + node := node + group.Go(func() error { + f(node) + return nil + }) + } + err := group.Wait() + if err != nil { + panic(err) + } +} + func (n Nodes) Connect() Nodes { wg := sync.WaitGroup{} for i, node := range n { diff --git a/test/cli/harness/run.go b/test/cli/harness/run.go index 9cbb871bc10..c2a3662be8b 100644 --- a/test/cli/harness/run.go +++ b/test/cli/harness/run.go @@ -51,7 +51,7 @@ func environToMap(environ []string) map[string]string { return m } -func (r *Runner) Run(req RunRequest) RunResult { +func (r *Runner) Run(req RunRequest) *RunResult { cmd := exec.Command(req.Path, req.Args...) stdout := &Buffer{} stderr := &Buffer{} @@ -86,17 +86,17 @@ func (r *Runner) Run(req RunRequest) RunResult { result.ExitErr = exitErr } - return result + return &result } // MustRun runs the command and fails the test if the command fails. -func (r *Runner) MustRun(req RunRequest) RunResult { +func (r *Runner) MustRun(req RunRequest) *RunResult { result := r.Run(req) r.AssertNoError(result) return result } -func (r *Runner) AssertNoError(result RunResult) { +func (r *Runner) AssertNoError(result *RunResult) { if result.ExitErr != nil { log.Panicf("'%s' returned error, code: %d, err: %s\nstdout:%s\nstderr:%s\n", result.Cmd.Args, result.ExitErr.ExitCode(), result.ExitErr.Error(), result.Stdout.String(), result.Stderr.String()) diff --git a/test/sharness/t0170-legacy-dht.sh b/test/sharness/t0170-legacy-dht.sh deleted file mode 100755 index fc11b9044dd..00000000000 --- a/test/sharness/t0170-legacy-dht.sh +++ /dev/null @@ -1,121 +0,0 @@ -#!/usr/bin/env bash - -# Legacy / deprecated, see: t0170-routing-dht.sh -test_description="Test dht command" - -. lib/test-lib.sh - -test_dht() { - NUM_NODES=5 - - test_expect_success 'init iptb' ' - rm -rf .iptb/ && - iptb testbed create -type localipfs -count $NUM_NODES -init - ' - - test_expect_success 'DHT-only routing' ' - iptb run -- ipfs config Routing.Type dht - ' - - startup_cluster $NUM_NODES $@ - - test_expect_success 'peer ids' ' - PEERID_0=$(iptb attr get 0 id) && - PEERID_2=$(iptb attr get 2 id) - ' - - # ipfs dht findpeer - test_expect_success 'findpeer' ' - ipfsi 1 dht findpeer $PEERID_0 | sort >actual && - ipfsi 0 id -f "" | cut -d / -f 1-5 | sort >expected && - test_cmp actual expected - ' - - # ipfs dht get - test_expect_success 'get with good keys works' ' - HASH="$(echo "hello world" | ipfsi 2 add -q)" && - ipfsi 2 name publish "/ipfs/$HASH" && - ipfsi 1 dht get "/ipns/$PEERID_2" >get_result - ' - - test_expect_success 'get with good keys contains the right value' ' - cat get_result | grep -aq "/ipfs/$HASH" - ' - - test_expect_success 'put round trips (#3124)' ' - ipfsi 0 dht put "/ipns/$PEERID_2" get_result | sort >putted && - [ -s putted ] || - test_fsh cat putted - ' - - test_expect_success 'put with bad keys fails (issue #5113)' ' - ipfsi 0 dht put "foo" <<putted - ipfsi 0 dht put "/pk/foo" <<>putted - ipfsi 0 dht put "/ipns/foo" <<>putted - [ ! -s putted ] || - test_fsh cat putted - ' - - test_expect_success 'put with bad keys returns error (issue #4611)' ' - test_must_fail ipfsi 0 dht put "foo" << afile && - HASH=$(ipfsi 3 add -q afile) - ' - - # ipfs dht findprovs - test_expect_success 'findprovs' ' - ipfsi 4 dht findprovs $HASH > provs && - iptb attr get 3 id > expected && - test_cmp provs expected - ' - - - # ipfs dht query - # - # We test all nodes. 4 nodes should see the same peer ID, one node (the - # closest) should see a different one. - - for i in $(test_seq 0 4); do - test_expect_success "query from $i" ' - ipfsi "$i" dht query "$HASH" | head -1 >closest-$i - ' - done - - test_expect_success "collecting results" ' - cat closest-* | sort | uniq -c | sed -e "s/ *\([0-9]\+\) .*/\1/g" | sort -g > actual && - echo 1 > expected && - echo 4 >> expected - ' - - test_expect_success "checking results" ' - test_cmp actual expected - ' - - test_expect_success 'stop iptb' ' - iptb stop - ' - - test_expect_success "dht commands fail when offline" ' - test_must_fail ipfsi 0 dht findprovs "$HASH" 2>err_findprovs && - test_must_fail ipfsi 0 dht findpeer "$HASH" 2>err_findpeer && - test_must_fail ipfsi 0 dht put "/ipns/$PEERID_2" "get_result" 2>err_put && - test_should_contain "this command must be run in online mode" err_findprovs && - test_should_contain "this command must be run in online mode" err_findpeer && - test_should_contain "this action must be run in online mode" err_put - ' -} - -test_dht -test_dht --enable-pubsub-experiment --enable-namesys-pubsub - -test_done From 840eaa75990c3efb67e4404c9f0e7d25f091c152 Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Wed, 8 Mar 2023 16:25:45 -0500 Subject: [PATCH 71/93] test: parallelize more of rcmgr Go tests --- test/cli/harness/node.go | 8 ---- test/cli/rcmgr_test.go | 82 ++++++++++++++++++++++++---------------- 2 files changed, 50 insertions(+), 40 deletions(-) diff --git a/test/cli/harness/node.go b/test/cli/harness/node.go index 181fca99bc4..cc251e11b0f 100644 --- a/test/cli/harness/node.go +++ b/test/cli/harness/node.go @@ -121,14 +121,6 @@ func (n *Node) UpdateUserSuppliedResourceManagerOverrides(f func(overrides *rcmg n.WriteUserSuppliedResourceOverrides(overrides) } -func (n *Node) UpdateConfigAndUserSuppliedResourceManagerOverrides(f func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig)) { - overrides := n.ReadUserResourceOverrides() - cfg := n.ReadConfig() - f(cfg, overrides) - n.WriteConfig(cfg) - n.WriteUserSuppliedResourceOverrides(overrides) -} - func (n *Node) IPFS(args ...string) *RunResult { res := n.RunIPFS(args...) n.Runner.AssertNoError(res) diff --git a/test/cli/rcmgr_test.go b/test/cli/rcmgr_test.go index fb644e1a746..51b2b0452e3 100644 --- a/test/cli/rcmgr_test.go +++ b/test/cli/rcmgr_test.go @@ -49,6 +49,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("Very high connmgr highwater", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() node.UpdateConfig(func(cfg *config.Config) { cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(1000) @@ -74,6 +75,7 @@ func TestRcmgr(t *testing.T) { node.StartDaemon() t.Run("conns and streams are above 800 for default connmgr settings", func(t *testing.T) { + t.Parallel() res := node.RunIPFS("swarm", "resources", "--enc=json") require.Equal(t, 0, res.ExitCode()) limits := unmarshalLimits(t, res.Stdout.Bytes()) @@ -87,6 +89,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("limits should succeed", func(t *testing.T) { + t.Parallel() res := node.RunIPFS("swarm", "resources", "--enc=json") assert.Equal(t, 0, res.ExitCode()) @@ -106,6 +109,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("swarm stats works", func(t *testing.T) { + t.Parallel() res := node.RunIPFS("swarm", "resources", "--enc=json") require.Equal(t, 0, res.ExitCode()) @@ -123,6 +127,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("smoke test transient scope", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { overrides.Transient.Memory = 88888 @@ -135,6 +140,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("smoke test service scope", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { overrides.Service = map[string]rcmgr.ResourceLimits{"foo": {Memory: 77777}} @@ -147,6 +153,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("smoke test protocol scope", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { overrides.Protocol = map[protocol.ID]rcmgr.ResourceLimits{"foo": {Memory: 66666}} @@ -159,6 +166,7 @@ func TestRcmgr(t *testing.T) { }) t.Run("smoke test peer scope", func(t *testing.T) { + t.Parallel() validPeerID, err := peer.Decode("QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN") assert.NoError(t, err) node := harness.NewT(t).NewNode().Init() @@ -172,13 +180,17 @@ func TestRcmgr(t *testing.T) { assert.Equal(t, rcmgr.LimitVal64(55555), limits.Peers[validPeerID].Memory) }) - t.Run("", func(t *testing.T) { + t.Run("blocking and allowlists", func(t *testing.T) { + t.Parallel() nodes := harness.NewT(t).NewNodes(3).Init() node0, node1, node2 := nodes[0], nodes[1], nodes[2] - // peerID0, peerID1, peerID2 := node0.PeerID(), node1.PeerID(), node2.PeerID() peerID1, peerID2 := node1.PeerID().String(), node2.PeerID().String() - node0.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + node0.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ResourceMgr.Enabled = config.True + cfg.Swarm.ResourceMgr.Allowlist = []string{"/ip4/0.0.0.0/ipcidr/0/p2p/" + peerID2} + }) + node0.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { *overrides = rcmgr.PartialLimitConfig{ System: rcmgr.ResourceLimits{ Conns: rcmgr.BlockAllLimit, @@ -186,91 +198,97 @@ func TestRcmgr(t *testing.T) { ConnsOutbound: rcmgr.BlockAllLimit, }, } - cfg.Swarm.ResourceMgr.Enabled = config.True - cfg.Swarm.ResourceMgr.Allowlist = []string{"/ip4/0.0.0.0/ipcidr/0/p2p/" + peerID2} }) nodes.StartDaemons() - t.Parallel() - t.Run("node 0 should fail to connect to node 1", func(t *testing.T) { + t.Run("node 0 should fail to connect to and ping node 1", func(t *testing.T) { + t.Parallel() res := node0.Runner.Run(harness.RunRequest{ Path: node0.IPFSBin, - Args: []string{"swarm", "connect", node1.SwarmAddrs()[0].String()}, + Args: []string{"swarm", "connect", node1.SwarmAddrsWithPeerIDs()[0].String()}, }) assert.Equal(t, 1, res.ExitCode()) assert.Contains(t, res.Stderr.String(), "failed to find any peer in table") + + res = node0.RunIPFS("ping", "-n2", peerID1) + assert.Equal(t, 1, res.ExitCode()) + assert.Contains(t, res.Stderr.String(), "Error: ping failed") }) - t.Run("node 0 should connect to node 2 since it is allowlisted", func(t *testing.T) { + t.Run("node 0 should connect to and ping node 2 since it is allowlisted", func(t *testing.T) { + t.Parallel() res := node0.Runner.Run(harness.RunRequest{ Path: node0.IPFSBin, - Args: []string{"swarm", "connect", node2.SwarmAddrs()[0].String()}, + Args: []string{"swarm", "connect", node2.SwarmAddrsWithPeerIDs()[0].String()}, }) assert.Equal(t, 0, res.ExitCode()) - }) - t.Run("node 0 should fail to ping node 1", func(t *testing.T) { - res := node0.RunIPFS("ping", "-n2", peerID1) - assert.Equal(t, 1, res.ExitCode()) - assert.Contains(t, res.Stderr.String(), "Error: ping failed") - }) - - t.Run("node 0 should be able to ping node 2", func(t *testing.T) { - res := node0.RunIPFS("ping", "-n2", peerID2) + res = node0.RunIPFS("ping", "-n2", peerID2) assert.Equal(t, 0, res.ExitCode()) }) }) t.Run("daemon should refuse to start if connmgr.highwater < resources inbound", func(t *testing.T) { - t.Parallel() t.Run("system conns", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() - node.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) + cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) + }) + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { *overrides = rcmgr.PartialLimitConfig{ System: rcmgr.ResourceLimits{Conns: 128}, } - cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) - cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) }) res := node.RunIPFS("daemon") assert.Equal(t, 1, res.ExitCode()) }) t.Run("system conns inbound", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() - node.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) + cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) + }) + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { *overrides = rcmgr.PartialLimitConfig{ System: rcmgr.ResourceLimits{ConnsInbound: 128}, } - cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) - cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) }) res := node.RunIPFS("daemon") assert.Equal(t, 1, res.ExitCode()) }) t.Run("system streams", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() - node.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) + cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) + }) + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { *overrides = rcmgr.PartialLimitConfig{ System: rcmgr.ResourceLimits{Streams: 128}, } - cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) - cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) }) res := node.RunIPFS("daemon") assert.Equal(t, 1, res.ExitCode()) }) t.Run("system streams inbound", func(t *testing.T) { + t.Parallel() node := harness.NewT(t).NewNode().Init() - node.UpdateConfigAndUserSuppliedResourceManagerOverrides(func(cfg *config.Config, overrides *rcmgr.PartialLimitConfig) { + node.UpdateConfig(func(cfg *config.Config) { + cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) + cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) + }) + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { *overrides = rcmgr.PartialLimitConfig{ System: rcmgr.ResourceLimits{StreamsInbound: 128}, } - cfg.Swarm.ConnMgr.HighWater = config.NewOptionalInteger(128) - cfg.Swarm.ConnMgr.LowWater = config.NewOptionalInteger(64) }) res := node.RunIPFS("daemon") From 2510f063643086f83a5ac3f70a2f56d1d373bf21 Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Wed, 8 Mar 2023 16:26:47 -0500 Subject: [PATCH 72/93] feat: add "autoclient" routing type This routing type is the same as "auto" but it creates the DHT in "client" mode and hence does not start a DHT server. --- cmd/ipfs/daemon.go | 61 ++++++++++++++----------- config/routing.go | 2 +- core/node/libp2p/routingopt.go | 5 +- docs/changelogs/v0.19.md | 6 +++ docs/config.md | 6 ++- test/cli/delegated_routing_http_test.go | 2 +- test/cli/dht_autoclient_test.go | 39 ++++++++++++++++ 7 files changed, 88 insertions(+), 33 deletions(-) create mode 100644 test/cli/dht_autoclient_test.go diff --git a/cmd/ipfs/daemon.go b/cmd/ipfs/daemon.go index 21495c498fa..880d26b0e42 100644 --- a/cmd/ipfs/daemon.go +++ b/cmd/ipfs/daemon.go @@ -45,32 +45,33 @@ import ( ) const ( - adjustFDLimitKwd = "manage-fdlimit" - enableGCKwd = "enable-gc" - initOptionKwd = "init" - initConfigOptionKwd = "init-config" - initProfileOptionKwd = "init-profile" - ipfsMountKwd = "mount-ipfs" - ipnsMountKwd = "mount-ipns" - migrateKwd = "migrate" - mountKwd = "mount" - offlineKwd = "offline" // global option - routingOptionKwd = "routing" - routingOptionSupernodeKwd = "supernode" - routingOptionDHTClientKwd = "dhtclient" - routingOptionDHTKwd = "dht" - routingOptionDHTServerKwd = "dhtserver" - routingOptionNoneKwd = "none" - routingOptionCustomKwd = "custom" - routingOptionDefaultKwd = "default" - routingOptionAutoKwd = "auto" - unencryptTransportKwd = "disable-transport-encryption" - unrestrictedAPIAccessKwd = "unrestricted-api" - writableKwd = "writable" - enablePubSubKwd = "enable-pubsub-experiment" - enableIPNSPubSubKwd = "enable-namesys-pubsub" - enableMultiplexKwd = "enable-mplex-experiment" - agentVersionSuffix = "agent-version-suffix" + adjustFDLimitKwd = "manage-fdlimit" + enableGCKwd = "enable-gc" + initOptionKwd = "init" + initConfigOptionKwd = "init-config" + initProfileOptionKwd = "init-profile" + ipfsMountKwd = "mount-ipfs" + ipnsMountKwd = "mount-ipns" + migrateKwd = "migrate" + mountKwd = "mount" + offlineKwd = "offline" // global option + routingOptionKwd = "routing" + routingOptionSupernodeKwd = "supernode" + routingOptionDHTClientKwd = "dhtclient" + routingOptionDHTKwd = "dht" + routingOptionDHTServerKwd = "dhtserver" + routingOptionNoneKwd = "none" + routingOptionCustomKwd = "custom" + routingOptionDefaultKwd = "default" + routingOptionAutoKwd = "auto" + routingOptionAutoClientKwd = "autoclient" + unencryptTransportKwd = "disable-transport-encryption" + unrestrictedAPIAccessKwd = "unrestricted-api" + writableKwd = "writable" + enablePubSubKwd = "enable-pubsub-experiment" + enableIPNSPubSubKwd = "enable-namesys-pubsub" + enableMultiplexKwd = "enable-mplex-experiment" + agentVersionSuffix = "agent-version-suffix" // apiAddrKwd = "address-api" // swarmAddrKwd = "address-swarm" ) @@ -416,6 +417,14 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment cfg.Identity.PeerID, cfg.Addresses.Swarm, cfg.Identity.PrivKey, + libp2p.DHTOption, + ) + case routingOptionAutoClientKwd: + ncfg.Routing = libp2p.ConstructDefaultRouting( + cfg.Identity.PeerID, + cfg.Addresses.Swarm, + cfg.Identity.PrivKey, + libp2p.DHTClientOption, ) case routingOptionDHTClientKwd: ncfg.Routing = libp2p.DHTClientOption diff --git a/config/routing.go b/config/routing.go index f19414ff308..1210bb3cecc 100644 --- a/config/routing.go +++ b/config/routing.go @@ -10,7 +10,7 @@ import ( type Routing struct { // Type sets default daemon routing mode. // - // Can be one of "auto", "dht", "dhtclient", "dhtserver", "none", or "custom". + // Can be one of "auto", "autoclient", "dht", "dhtclient", "dhtserver", "none", or "custom". // When unset or set to "auto", DHT and implicit routers are used. // When "custom" is set, user-provided Routing.Routers is used. Type *OptionalString `json:",omitempty"` diff --git a/core/node/libp2p/routingopt.go b/core/node/libp2p/routingopt.go index bfb45971cc9..d54f37acc5c 100644 --- a/core/node/libp2p/routingopt.go +++ b/core/node/libp2p/routingopt.go @@ -40,7 +40,7 @@ func init() { } // ConstructDefaultRouting returns routers used when Routing.Type is unset or set to "auto" -func ConstructDefaultRouting(peerID string, addrs []string, privKey string) func( +func ConstructDefaultRouting(peerID string, addrs []string, privKey string, routingOpt RoutingOption) func( ctx context.Context, host host.Host, dstore datastore.Batching, @@ -58,8 +58,7 @@ func ConstructDefaultRouting(peerID string, addrs []string, privKey string) func // Different trade-offs can be made by setting Routing.Type = "custom" with own Routing.Routers var routers []*routinghelpers.ParallelRouter - // Run the default DHT routing (same as Routing.Type = "dht") - dhtRouting, err := DHTOption(ctx, host, dstore, validator, bootstrapPeers...) + dhtRouting, err := routingOpt(ctx, host, dstore, validator, bootstrapPeers...) if err != nil { return nil, err } diff --git a/docs/changelogs/v0.19.md b/docs/changelogs/v0.19.md index 7663308a6db..fede7a4547f 100644 --- a/docs/changelogs/v0.19.md +++ b/docs/changelogs/v0.19.md @@ -7,6 +7,7 @@ - [Overview](#overview) - [🔦 Highlights](#-highlights) - [Improving the libp2p resource management integration](#improving-the-libp2p-resource-management-integration) + - [Addition of "autoclient" router type](#addition-of-autoclient-router-type) - [📝 Changelog](#-changelog) - [👨‍👩‍👧‍👦 Contributors](#-contributors) @@ -22,6 +23,11 @@ and [0.18.1](https://github.com/ipfs/kubo/blob/master/docs/changelogs/v0.18.md#i - Note: we don't expect most users to need these capablities, but they are there if so. 1. [Doc updates](https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md). +#### Addition of "autoclient" router type +A new routing type "autoclient" has been added. This mode is similar to "auto", in that it is a hybrid of content routers (including Kademlia and HTTP routers), but it does not run a DHT server. This is similar to the difference between "dhtclient" and "dht" router types. + +See the [Routing.Type documentation](https://github.com/ipfs/kubo/blob/master/docs/config.md#routingtype) for more information. + ### 📝 Changelog ### 👨‍👩‍👧‍👦 Contributors diff --git a/docs/config.md b/docs/config.md index 30a4e760134..de47e544511 100644 --- a/docs/config.md +++ b/docs/config.md @@ -1349,11 +1349,13 @@ Contains options for content, peer, and IPNS routing mechanisms. ### `Routing.Type` -There are multiple routing options: "auto", "none", "dht" and "custom". +There are multiple routing options: "auto", "autoclient", "none", "dht", "dhtclient", and "custom". * **DEFAULT:** If unset, or set to "auto", your node will use the IPFS DHT and parallel HTTP routers listed below for additional speed. +* If set to "autoclient", your node will behave as in "auto" but without running a DHT server. + * If set to "none", your node will use _no_ routing system. You'll have to explicitly connect to peers that have the content you're looking for. @@ -1379,7 +1381,7 @@ To force a specific DHT-only mode, client or server, set `Routing.Type` to `dhtclient` or `dhtserver` respectively. Please do not set this to `dhtserver` unless you're sure your node is reachable from the public network. -When `Routing.Type` is set to `auto` your node will accelerate some types of routing +When `Routing.Type` is set to `auto` or `autoclient` your node will accelerate some types of routing by leveraging HTTP endpoints compatible with [IPIP-337](https://github.com/ipfs/specs/pull/337) in addition to the IPFS DHT. By default, an instance of [IPNI](https://github.com/ipni/specs/blob/main/IPNI.md#readme) diff --git a/test/cli/delegated_routing_http_test.go b/test/cli/delegated_routing_http_test.go index 0b39a9b12e6..446ea515049 100644 --- a/test/cli/delegated_routing_http_test.go +++ b/test/cli/delegated_routing_http_test.go @@ -94,7 +94,7 @@ func TestHTTPDelegatedRouting(t *testing.T) { })) t.Cleanup(server.Close) - node.IPFS("config", "Routing.Type", "--json", `"custom"`) + node.IPFS("config", "Routing.Type", "custom") node.IPFS("config", "Routing.Routers.TestDelegatedRouter", "--json", ToJSONStr(JSONObj{ "Type": "http", "Parameters": JSONObj{ diff --git a/test/cli/dht_autoclient_test.go b/test/cli/dht_autoclient_test.go new file mode 100644 index 00000000000..749e34b348e --- /dev/null +++ b/test/cli/dht_autoclient_test.go @@ -0,0 +1,39 @@ +package cli + +import ( + "bytes" + "testing" + + "github.com/ipfs/kubo/test/cli/harness" + "github.com/ipfs/kubo/test/cli/testutils" + "github.com/stretchr/testify/assert" +) + +func TestDHTAutoclient(t *testing.T) { + t.Parallel() + nodes := harness.NewT(t).NewNodes(10).Init() + harness.Nodes(nodes[8:]).ForEachPar(func(node *harness.Node) { + node.IPFS("config", "Routing.Type", "autoclient") + }) + nodes.StartDaemons().Connect() + + t.Run("file added on node in client mode is retrievable from node in client mode", func(t *testing.T) { + t.Parallel() + randomBytes := testutils.RandomBytes(1000) + hash := nodes[8].IPFSAdd(bytes.NewReader(randomBytes)) + + res := nodes[9].IPFS("cat", hash) + assert.Equal(t, randomBytes, []byte(res.Stdout.Trimmed())) + }) + + t.Run("file added on node in server mode is retrievable from all nodes", func(t *testing.T) { + t.Parallel() + randomBytes := testutils.RandomBytes(1000) + hash := nodes[0].IPFSAdd(bytes.NewReader(randomBytes)) + + for i := 0; i < 10; i++ { + res := nodes[i].IPFS("cat", hash) + assert.Equal(t, randomBytes, []byte(res.Stdout.Trimmed())) + } + }) +} From 6bab5ce37ca9a525a9ce16c21a1251947529e0e1 Mon Sep 17 00:00:00 2001 From: Laurent Senta Date: Thu, 9 Mar 2023 15:21:50 +0100 Subject: [PATCH 73/93] test: name --verify forgets the verified key --- test/sharness/t0100-name.sh | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/test/sharness/t0100-name.sh b/test/sharness/t0100-name.sh index 44c2afb2d69..34f33ea4d89 100755 --- a/test/sharness/t0100-name.sh +++ b/test/sharness/t0100-name.sh @@ -314,4 +314,32 @@ test_name_with_key 'rsa' test_name_with_key 'ed25519_b58' test_name_with_key 'ed25519_b36' + +# `ipfs name inspect --verify` using the wrong RSA key should not succeed + +test_init_ipfs +test_launch_ipfs_daemon + +test_expect_success "prepare RSA keys" ' + export KEY_1=`ipfs key gen --type=rsa --size=4096 key1` && + export KEY_2=`ipfs key gen --type=rsa --size=4096 key2` && + export PEERID_1=`ipfs key list --ipns-base=base36 -l | grep key1 | cut -d " " -f1` && + export PEERID_2=`ipfs key list --ipns-base=base36 -l | grep key2 | cut -d " " -f1` +' + +test_expect_success "ipfs name publish --allow-offline --key= ' succeeds" ' + ipfs name publish --allow-offline --key=${KEY_1} "/ipfs/$( echo "helloworld" | ipfs add --inline -q )" && + ipfs routing get "/ipns/$PEERID_1" > ipns_record +' + +test_expect_success "ipfs name inspect --verify' has '.Validation.Validity' set to 'true' with correct Peer ID" ' + ipfs name inspect --verify $PEERID_1 --enc json < ipns_record | jq -e ".Validation.Valid == true" +' + +test_expect_success "ipfs name inspect --verify' has '.Validation.Validity' set to 'false' when we verify the wrong Peer ID" ' + ipfs name inspect --verify $PEERID_2 --enc json < ipns_record | jq -e ".Validation.Valid == false" +' + +test_kill_ipfs_daemon + test_done From d001ed74513eab7aee0fbef5f3c5ea0d94ca43e9 Mon Sep 17 00:00:00 2001 From: Laurent Senta Date: Thu, 9 Mar 2023 15:23:52 +0100 Subject: [PATCH 74/93] fix: --verify forgets the verified key --- core/commands/name/name.go | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/core/commands/name/name.go b/core/commands/name/name.go index 7999aee3ddc..0e4fa6cb548 100644 --- a/core/commands/name/name.go +++ b/core/commands/name/name.go @@ -222,6 +222,20 @@ Passing --verify will verify signature against provided public key. // Peer ID. if len(entry.PubKey) > 0 { pub, err = ic.UnmarshalPublicKey(entry.PubKey) + if err != nil { + return err + } + + // Verify the public key matches the name we are verifying. + entryID, err := peer.IDFromPublicKey(pub) + + if err != nil { + return err + } + + if id != entryID { + return fmt.Errorf("record public key does not match the verified name") + } } } if err != nil { From 5f766619cf5c8856edc06139d4338753c444577c Mon Sep 17 00:00:00 2001 From: Eng Zer Jun Date: Wed, 10 Aug 2022 22:04:19 +0800 Subject: [PATCH 75/93] test: use `T.TempDir` to create temporary test directory This commit replaces `os.MkdirTemp` with `t.TempDir` in tests. The directory created by `t.TempDir` is automatically removed when the test and all its subtests complete. Prior to this commit, temporary directory created using `os.MkdirTemp` needs to be removed manually by calling `os.RemoveAll`, which is omitted in some tests. The error handling boilerplate e.g. defer func() { if err := os.RemoveAll(dir); err != nil { t.Fatal(err) } } is also tedious, but `t.TempDir` handles this for us nicely. Reference: https://pkg.go.dev/testing#T.TempDir Signed-off-by: Eng Zer Jun --- fuse/node/mount_test.go | 10 +++------- repo/fsrepo/config_test.go | 25 ++++--------------------- repo/fsrepo/fsrepo_test.go | 21 ++++++--------------- test/bench/bench_cli_ipfs_add/main.go | 7 +------ test/bench/offline_add/main.go | 6 +----- 5 files changed, 15 insertions(+), 54 deletions(-) diff --git a/fuse/node/mount_test.go b/fuse/node/mount_test.go index 12313ae3ea6..1691cfa5ba2 100644 --- a/fuse/node/mount_test.go +++ b/fuse/node/mount_test.go @@ -4,6 +4,7 @@ package node import ( + "context" "os" "strings" "testing" @@ -11,8 +12,6 @@ import ( "bazil.org/fuse" - "context" - core "github.com/ipfs/kubo/core" ipns "github.com/ipfs/kubo/fuse/ipns" mount "github.com/ipfs/kubo/fuse/mount" @@ -52,11 +51,8 @@ func TestExternalUnmount(t *testing.T) { t.Fatal(err) } - // get the test dir paths (/tmp/fusetestXXXX) - dir, err := os.MkdirTemp("", "fusetest") - if err != nil { - t.Fatal(err) - } + // get the test dir paths (/tmp/TestExternalUnmount) + dir := t.TempDir() ipfsDir := dir + "/ipfs" ipnsDir := dir + "/ipns" diff --git a/repo/fsrepo/config_test.go b/repo/fsrepo/config_test.go index 03af75a9631..060d0222ada 100644 --- a/repo/fsrepo/config_test.go +++ b/repo/fsrepo/config_test.go @@ -2,7 +2,6 @@ package fsrepo_test import ( "encoding/json" - "os" "reflect" "testing" @@ -88,11 +87,7 @@ func TestDefaultDatastoreConfig(t *testing.T) { t.Fatal(err) } - dir, err := os.MkdirTemp("", "ipfs-datastore-config-test") - if err != nil { - t.Fatal(err) - } - defer os.RemoveAll(dir) // clean up + dir := t.TempDir() config := new(config.Datastore) err = json.Unmarshal(defaultConfig, config) @@ -126,11 +121,7 @@ func TestLevelDbConfig(t *testing.T) { if err != nil { t.Fatal(err) } - dir, err := os.MkdirTemp("", "ipfs-datastore-config-test") - if err != nil { - t.Fatal(err) - } - defer os.RemoveAll(dir) // clean up + dir := t.TempDir() spec := make(map[string]interface{}) err = json.Unmarshal(leveldbConfig, &spec) @@ -164,11 +155,7 @@ func TestFlatfsConfig(t *testing.T) { if err != nil { t.Fatal(err) } - dir, err := os.MkdirTemp("", "ipfs-datastore-config-test") - if err != nil { - t.Fatal(err) - } - defer os.RemoveAll(dir) // clean up + dir := t.TempDir() spec := make(map[string]interface{}) err = json.Unmarshal(flatfsConfig, &spec) @@ -202,11 +189,7 @@ func TestMeasureConfig(t *testing.T) { if err != nil { t.Fatal(err) } - dir, err := os.MkdirTemp("", "ipfs-datastore-config-test") - if err != nil { - t.Fatal(err) - } - defer os.RemoveAll(dir) // clean up + dir := t.TempDir() spec := make(map[string]interface{}) err = json.Unmarshal(measureConfig, &spec) diff --git a/repo/fsrepo/fsrepo_test.go b/repo/fsrepo/fsrepo_test.go index 7c7551d205d..6b30b107adb 100644 --- a/repo/fsrepo/fsrepo_test.go +++ b/repo/fsrepo/fsrepo_test.go @@ -13,18 +13,9 @@ import ( config "github.com/ipfs/kubo/config" ) -// swap arg order -func testRepoPath(p string, t *testing.T) string { - name, err := os.MkdirTemp("", p) - if err != nil { - t.Fatal(err) - } - return name -} - func TestInitIdempotence(t *testing.T) { t.Parallel() - path := testRepoPath("", t) + path := t.TempDir() for i := 0; i < 10; i++ { assert.Nil(Init(path, &config.Config{Datastore: config.DefaultDatastoreConfig()}), t, "multiple calls to init should succeed") } @@ -37,8 +28,8 @@ func Remove(repoPath string) error { func TestCanManageReposIndependently(t *testing.T) { t.Parallel() - pathA := testRepoPath("a", t) - pathB := testRepoPath("b", t) + pathA := t.TempDir() + pathB := t.TempDir() t.Log("initialize two repos") assert.Nil(Init(pathA, &config.Config{Datastore: config.DefaultDatastoreConfig()}), t, "a", "should initialize successfully") @@ -65,7 +56,7 @@ func TestCanManageReposIndependently(t *testing.T) { func TestDatastoreGetNotAllowedAfterClose(t *testing.T) { t.Parallel() - path := testRepoPath("test", t) + path := t.TempDir() assert.True(!IsInitialized(path), t, "should NOT be initialized") assert.Nil(Init(path, &config.Config{Datastore: config.DefaultDatastoreConfig()}), t, "should initialize successfully") @@ -83,7 +74,7 @@ func TestDatastoreGetNotAllowedAfterClose(t *testing.T) { func TestDatastorePersistsFromRepoToRepo(t *testing.T) { t.Parallel() - path := testRepoPath("test", t) + path := t.TempDir() assert.Nil(Init(path, &config.Config{Datastore: config.DefaultDatastoreConfig()}), t) r1, err := Open(path) @@ -104,7 +95,7 @@ func TestDatastorePersistsFromRepoToRepo(t *testing.T) { func TestOpenMoreThanOnceInSameProcess(t *testing.T) { t.Parallel() - path := testRepoPath("", t) + path := t.TempDir() assert.Nil(Init(path, &config.Config{Datastore: config.DefaultDatastoreConfig()}), t) r1, err := Open(path) diff --git a/test/bench/bench_cli_ipfs_add/main.go b/test/bench/bench_cli_ipfs_add/main.go index a089410ef39..e7fe90e0407 100644 --- a/test/bench/bench_cli_ipfs_add/main.go +++ b/test/bench/bench_cli_ipfs_add/main.go @@ -45,12 +45,7 @@ func benchmarkAdd(amount int64) (*testing.BenchmarkResult, error) { b.SetBytes(amount) for i := 0; i < b.N; i++ { b.StopTimer() - tmpDir, err := os.MkdirTemp("", "") - if err != nil { - benchmarkError = err - b.Fatal(err) - } - defer os.RemoveAll(tmpDir) + tmpDir := b.TempDir() env := append( []string{fmt.Sprintf("%s=%s", config.EnvDir, path.Join(tmpDir, config.DefaultPathName))}, // first in order to override diff --git a/test/bench/offline_add/main.go b/test/bench/offline_add/main.go index a15ebcffda2..338a5f6ac24 100644 --- a/test/bench/offline_add/main.go +++ b/test/bench/offline_add/main.go @@ -37,11 +37,7 @@ func benchmarkAdd(amount int64) (*testing.BenchmarkResult, error) { b.SetBytes(amount) for i := 0; i < b.N; i++ { b.StopTimer() - tmpDir, err := os.MkdirTemp("", "") - if err != nil { - b.Fatal(err) - } - defer os.RemoveAll(tmpDir) + tmpDir := b.TempDir() env := append(os.Environ(), fmt.Sprintf("%s=%s", config.EnvDir, path.Join(tmpDir, config.DefaultPathName))) setupCmd := func(cmd *exec.Cmd) { From b4211be7d6147193882efb6e4da1aecabe71a563 Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Fri, 16 Dec 2022 06:55:03 -0500 Subject: [PATCH 76/93] test: port peering test from sharness to Go This is the slowest test in the sharness test suite, because it has very long sleeps. It usually takes 2+ minutes to run. This new impl runs all peering tests in about 20 seconds, since it polls for conditions instead of sleeping, and runs the tests in parallel. This also has an additional test case for a peer that was never online and then connects. --- test/cli/harness/harness.go | 21 +++++ test/cli/harness/log.go | 155 +++++++++++++++++++++++++++++++++ test/cli/harness/node.go | 25 +++++- test/cli/harness/nodes.go | 20 +---- test/cli/peering_test.go | 141 ++++++++++++++++++++++++++++++ test/cli/testutils/strings.go | 14 +++ test/sharness/t0171-peering.sh | 127 --------------------------- 7 files changed, 358 insertions(+), 145 deletions(-) create mode 100644 test/cli/harness/log.go create mode 100644 test/cli/peering_test.go delete mode 100755 test/sharness/t0171-peering.sh diff --git a/test/cli/harness/harness.go b/test/cli/harness/harness.go index a35fead3512..e68116b5efc 100644 --- a/test/cli/harness/harness.go +++ b/test/cli/harness/harness.go @@ -11,6 +11,8 @@ import ( logging "github.com/ipfs/go-log/v2" . "github.com/ipfs/kubo/test/cli/testutils" + "github.com/libp2p/go-libp2p/core/peer" + "github.com/multiformats/go-multiaddr" ) // Harness tracks state for a test, such as temp dirs and IFPS nodes, and cleans them up after the test. @@ -188,3 +190,22 @@ func (h *Harness) Cleanup() { log.Panicf("removing temp dir %s: %s", h.Dir, err) } } + +// ExtractPeerID extracts a peer ID from the given multiaddr, and fatals if it does not contain a peer ID. +func (h *Harness) ExtractPeerID(m multiaddr.Multiaddr) peer.ID { + var peerIDStr string + multiaddr.ForEach(m, func(c multiaddr.Component) bool { + if c.Protocol().Code == multiaddr.P_P2P { + peerIDStr = c.Value() + } + return true + }) + if peerIDStr == "" { + panic(multiaddr.ErrProtocolNotFound) + } + peerID, err := peer.Decode(peerIDStr) + if err != nil { + panic(err) + } + return peerID +} diff --git a/test/cli/harness/log.go b/test/cli/harness/log.go new file mode 100644 index 00000000000..d76bb2747c1 --- /dev/null +++ b/test/cli/harness/log.go @@ -0,0 +1,155 @@ +package harness + +import ( + "fmt" + "path/filepath" + "runtime" + "sort" + "strings" + "sync" + "testing" + "time" +) + +type event struct { + timestamp time.Time + msg string +} + +type events []*event + +func (e events) Len() int { return len(e) } +func (e events) Less(i, j int) bool { return e[i].timestamp.Before(e[j].timestamp) } +func (e events) Swap(i, j int) { e[i], e[j] = e[j], e[i] } + +// TestLogger is a logger for tests. +// It buffers output and only writes the output if the test fails or output is explicitly turned on. +// The purpose of this logger is to allow Go test to run with the verbose flag without printing logs. +// The verbose flag is useful since it streams test progress, but also printing logs makes the output too verbose. +// +// You can also add prefixes that are prepended to each log message, for extra logging context. +// +// This is implemented as a hierarchy of loggers, with children flushing log entries back to parents. +// This works because t.Cleanup() processes entries in LIFO order, so children always flush first. +// +// Obviously this logger should never be used in production systems. +type TestLogger struct { + parent *TestLogger + children []*TestLogger + prefixes []string + prefixesIface []any + t *testing.T + buf events + m sync.Mutex + logsEnabled bool +} + +func NewTestLogger(t *testing.T) *TestLogger { + l := &TestLogger{t: t, buf: make(events, 0)} + t.Cleanup(l.flush) + return l +} + +func (t *TestLogger) buildPrefix(timestamp time.Time) string { + d := timestamp.Format("2006-01-02T15:04:05.999999") + _, file, lineno, _ := runtime.Caller(2) + file = filepath.Base(file) + caller := fmt.Sprintf("%s:%d", file, lineno) + + if len(t.prefixes) == 0 { + return fmt.Sprintf("%s\t%s\t", d, caller) + } + + prefixes := strings.Join(t.prefixes, ":") + return fmt.Sprintf("%s\t%s\t%s: ", d, caller, prefixes) +} + +func (t *TestLogger) Log(args ...any) { + timestamp := time.Now() + e := t.buildPrefix(timestamp) + fmt.Sprint(args...) + t.add(&event{timestamp: timestamp, msg: e}) +} + +func (t *TestLogger) Logf(format string, args ...any) { + timestamp := time.Now() + e := t.buildPrefix(timestamp) + fmt.Sprintf(format, args...) + t.add(&event{timestamp: timestamp, msg: e}) +} + +func (t *TestLogger) Fatal(args ...any) { + timestamp := time.Now() + e := t.buildPrefix(timestamp) + fmt.Sprint(append([]any{"fatal: "}, args...)...) + t.add(&event{timestamp: timestamp, msg: e}) + t.t.FailNow() +} + +func (t *TestLogger) Fatalf(format string, args ...any) { + timestamp := time.Now() + e := t.buildPrefix(timestamp) + fmt.Sprintf(fmt.Sprintf("fatal: %s", format), args...) + t.add(&event{timestamp: timestamp, msg: e}) + t.t.FailNow() +} + +func (t *TestLogger) add(e *event) { + t.m.Lock() + defer t.m.Unlock() + t.buf = append(t.buf, e) +} + +func (t *TestLogger) AddPrefix(prefix string) *TestLogger { + l := &TestLogger{ + prefixes: append(t.prefixes, prefix), + prefixesIface: append(t.prefixesIface, prefix), + t: t.t, + parent: t, + logsEnabled: t.logsEnabled, + } + t.m.Lock() + defer t.m.Unlock() + + t.children = append(t.children, l) + t.t.Cleanup(l.flush) + + return l +} + +func (t *TestLogger) EnableLogs() { + t.m.Lock() + defer t.m.Unlock() + t.logsEnabled = true + if t.parent != nil { + if t.parent.logsEnabled { + t.parent.EnableLogs() + } + } + fmt.Printf("enabling %d children\n", len(t.children)) + for _, c := range t.children { + if !c.logsEnabled { + c.EnableLogs() + } + } +} + +func (t *TestLogger) flush() { + if t.t.Failed() || t.logsEnabled { + t.m.Lock() + defer t.m.Unlock() + // if this is a child, send the events to the parent + // the root parent will print all the events in sorted order + if t.parent != nil { + for _, e := range t.buf { + t.parent.add(e) + } + } else { + // we're the root, sort all the events and then print them + sort.Sort(t.buf) + fmt.Println() + fmt.Printf("Logs for test %q:\n\n", t.t.Name()) + for _, e := range t.buf { + fmt.Println(e.msg) + } + fmt.Println() + } + t.buf = nil + } +} diff --git a/test/cli/harness/node.go b/test/cli/harness/node.go index cc251e11b0f..f740ab1b19f 100644 --- a/test/cli/harness/node.go +++ b/test/cli/harness/node.go @@ -453,9 +453,8 @@ func (n *Node) Peers() []multiaddr.Multiaddr { Path: n.IPFSBin, Args: []string{"swarm", "peers"}, }) - lines := strings.Split(strings.TrimSpace(res.Stdout.String()), "\n") var addrs []multiaddr.Multiaddr - for _, line := range lines { + for _, line := range res.Stdout.Lines() { ma, err := multiaddr.NewMultiaddr(line) if err != nil { panic(err) @@ -465,6 +464,28 @@ func (n *Node) Peers() []multiaddr.Multiaddr { return addrs } +func (n *Node) PeerWith(other *Node) { + n.UpdateConfig(func(cfg *config.Config) { + var addrs []multiaddr.Multiaddr + for _, addrStr := range other.ReadConfig().Addresses.Swarm { + ma, err := multiaddr.NewMultiaddr(addrStr) + if err != nil { + panic(err) + } + addrs = append(addrs, ma) + } + + cfg.Peering.Peers = append(cfg.Peering.Peers, peer.AddrInfo{ + ID: other.PeerID(), + Addrs: addrs, + }) + }) +} + +func (n *Node) Disconnect(other *Node) { + n.IPFS("swarm", "disconnect", "/p2p/"+other.PeerID().String()) +} + // GatewayURL waits for the gateway file and then returns its contents or times out. func (n *Node) GatewayURL() string { timer := time.NewTimer(1 * time.Second) diff --git a/test/cli/harness/nodes.go b/test/cli/harness/nodes.go index 872d7767913..78662afbbea 100644 --- a/test/cli/harness/nodes.go +++ b/test/cli/harness/nodes.go @@ -3,6 +3,7 @@ package harness import ( "sync" + . "github.com/ipfs/kubo/test/cli/testutils" "github.com/multiformats/go-multiaddr" "golang.org/x/sync/errgroup" ) @@ -11,9 +12,7 @@ import ( type Nodes []*Node func (n Nodes) Init(args ...string) Nodes { - for _, node := range n { - node.Init() - } + ForEachPar(n, func(node *Node) { node.Init(args...) }) return n } @@ -59,22 +58,11 @@ func (n Nodes) Connect() Nodes { } func (n Nodes) StartDaemons() Nodes { - wg := sync.WaitGroup{} - for _, node := range n { - wg.Add(1) - node := node - go func() { - defer wg.Done() - node.StartDaemon() - }() - } - wg.Wait() + ForEachPar(n, func(node *Node) { node.StartDaemon() }) return n } func (n Nodes) StopDaemons() Nodes { - for _, node := range n { - node.StopDaemon() - } + ForEachPar(n, func(node *Node) { node.StopDaemon() }) return n } diff --git a/test/cli/peering_test.go b/test/cli/peering_test.go new file mode 100644 index 00000000000..f3e797fae80 --- /dev/null +++ b/test/cli/peering_test.go @@ -0,0 +1,141 @@ +package cli + +import ( + "fmt" + "math/rand" + "testing" + "time" + + "github.com/ipfs/kubo/config" + "github.com/ipfs/kubo/test/cli/harness" + . "github.com/ipfs/kubo/test/cli/testutils" + "github.com/libp2p/go-libp2p/core/peer" + "github.com/stretchr/testify/assert" +) + +func TestPeering(t *testing.T) { + t.Parallel() + + type peering struct { + from int + to int + } + + newRandPort := func() int { + n := rand.Int() + return 3000 + (n % 1000) + } + + containsPeerID := func(p peer.ID, peers []peer.ID) bool { + for _, peerID := range peers { + if p == peerID { + return true + } + } + return false + } + + assertPeered := func(h *harness.Harness, from *harness.Node, to *harness.Node) { + assert.Eventuallyf(t, func() bool { + fromPeers := from.Peers() + if len(fromPeers) == 0 { + return false + } + var fromPeerIDs []peer.ID + for _, p := range fromPeers { + fromPeerIDs = append(fromPeerIDs, h.ExtractPeerID(p)) + } + return containsPeerID(to.PeerID(), fromPeerIDs) + }, 20*time.Second, 10*time.Millisecond, "%d -> %d not peered", from.ID, to.ID) + } + + assertNotPeered := func(h *harness.Harness, from *harness.Node, to *harness.Node) { + assert.Eventuallyf(t, func() bool { + fromPeers := from.Peers() + if len(fromPeers) == 0 { + return false + } + var fromPeerIDs []peer.ID + for _, p := range fromPeers { + fromPeerIDs = append(fromPeerIDs, h.ExtractPeerID(p)) + } + return !containsPeerID(to.PeerID(), fromPeerIDs) + }, 20*time.Second, 10*time.Millisecond, "%d -> %d peered", from.ID, to.ID) + } + + assertPeerings := func(h *harness.Harness, nodes []*harness.Node, peerings []peering) { + ForEachPar(peerings, func(peering peering) { + assertPeered(h, nodes[peering.from], nodes[peering.to]) + }) + } + + createNodes := func(t *testing.T, n int, peerings []peering) (*harness.Harness, harness.Nodes) { + h := harness.NewT(t) + nodes := h.NewNodes(n).Init() + nodes.ForEachPar(func(node *harness.Node) { + node.UpdateConfig(func(cfg *config.Config) { + cfg.Routing.Type = config.NewOptionalString("none") + cfg.Addresses.Swarm = []string{fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", newRandPort())} + }) + + }) + + for _, peering := range peerings { + nodes[peering.from].PeerWith(nodes[peering.to]) + } + + return h, nodes + } + + t.Run("bidirectional peering should work (simultaneous connect)", func(t *testing.T) { + t.Parallel() + peerings := []peering{{from: 0, to: 1}, {from: 1, to: 0}, {from: 1, to: 2}} + h, nodes := createNodes(t, 3, peerings) + + nodes.StartDaemons() + assertPeerings(h, nodes, peerings) + + nodes[0].Disconnect(nodes[1]) + assertPeerings(h, nodes, peerings) + }) + + t.Run("1 should reconnect to 2 when 2 disconnects from 1", func(t *testing.T) { + t.Parallel() + peerings := []peering{{from: 0, to: 1}, {from: 1, to: 0}, {from: 1, to: 2}} + h, nodes := createNodes(t, 3, peerings) + + nodes.StartDaemons() + assertPeerings(h, nodes, peerings) + + nodes[2].Disconnect(nodes[1]) + assertPeerings(h, nodes, peerings) + }) + + t.Run("1 will peer with 2 when it comes online", func(t *testing.T) { + t.Parallel() + peerings := []peering{{from: 0, to: 1}, {from: 1, to: 0}, {from: 1, to: 2}} + h, nodes := createNodes(t, 3, peerings) + + nodes[0].StartDaemon() + nodes[1].StartDaemon() + assertPeerings(h, nodes, []peering{{from: 0, to: 1}, {from: 1, to: 0}}) + + nodes[2].StartDaemon() + assertPeerings(h, nodes, peerings) + }) + + t.Run("1 will re-peer with 2 when it disconnects and then comes back online", func(t *testing.T) { + t.Parallel() + peerings := []peering{{from: 0, to: 1}, {from: 1, to: 0}, {from: 1, to: 2}} + h, nodes := createNodes(t, 3, peerings) + + nodes.StartDaemons() + assertPeerings(h, nodes, peerings) + + nodes[2].StopDaemon() + assertNotPeered(h, nodes[1], nodes[2]) + + nodes[2].StartDaemon() + assertPeerings(h, nodes, peerings) + }) +} diff --git a/test/cli/testutils/strings.go b/test/cli/testutils/strings.go index 1fb1512485e..110051e679f 100644 --- a/test/cli/testutils/strings.go +++ b/test/cli/testutils/strings.go @@ -7,6 +7,7 @@ import ( "net/netip" "net/url" "strings" + "sync" "github.com/multiformats/go-multiaddr" manet "github.com/multiformats/go-multiaddr/net" @@ -75,3 +76,16 @@ func URLStrToMultiaddr(u string) multiaddr.Multiaddr { } return ma } + +// ForEachPar invokes f in a new goroutine for each element of s and waits for all to complete. +func ForEachPar[T any](s []T, f func(T)) { + wg := sync.WaitGroup{} + wg.Add(len(s)) + for _, x := range s { + go func(x T) { + defer wg.Done() + f(x) + }(x) + } + wg.Wait() +} diff --git a/test/sharness/t0171-peering.sh b/test/sharness/t0171-peering.sh deleted file mode 100755 index 207b279803a..00000000000 --- a/test/sharness/t0171-peering.sh +++ /dev/null @@ -1,127 +0,0 @@ -#!/usr/bin/env bash - -test_description="Test peering service" - -. lib/test-lib.sh - -NUM_NODES=3 - -test_expect_success 'init iptb' ' - rm -rf .iptb/ && - iptb testbed create -type localipfs -count $NUM_NODES -init -' - -test_expect_success 'disabling routing' ' - iptb run -- ipfs config Routing.Type none -' - -for i in $(seq 0 2); do - ADDR="$(printf '["/ip4/127.0.0.1/tcp/%s"]' "$(( 3000 + ( RANDOM % 1000 ) ))")" - test_expect_success "configuring node $i to listen on $ADDR" ' - ipfsi "$i" config --json Addresses.Swarm "$ADDR" - ' -done - -peer_id() { - ipfsi "$1" config Identity.PeerID -} - -peer_addrs() { - ipfsi "$1" config Addresses.Swarm -} - -peer() { - PEER1="$1" && - PEER2="$2" && - PEER_LIST="$(ipfsi "$PEER1" config Peering.Peers || true)" && - { [[ "$PEER_LIST" == "null" ]] || PEER_LIST_INNER="${PEER_LIST:1:-1}"; } && - ADDR_INFO="$(printf '[%s{"ID": "%s", "Addrs": %s}]' \ - "${PEER_LIST_INNER:+${PEER_LIST_INNER},}" \ - "$(peer_id "$PEER2")" \ - "$(peer_addrs "$PEER2")")" && - ipfsi "$PEER1" config --json Peering.Peers "${ADDR_INFO}" -} - -# Peer: -# - 0 <-> 1 -# - 1 -> 2 -test_expect_success 'configure peering' ' - peer 0 1 && - peer 1 0 && - peer 1 2 -' - -list_peers() { - ipfsi "$1" swarm peers | sed 's|.*/p2p/\([^/]*\)$|\1|' | sort -u -} - -check_peers() { - sleep 20 # give it some time to settle. - test_expect_success 'verifying peering for peer 0' ' - list_peers 0 > peers_0_actual && - peer_id 1 > peers_0_expected && - test_cmp peers_0_expected peers_0_actual - ' - - test_expect_success 'verifying peering for peer 1' ' - list_peers 1 > peers_1_actual && - { peer_id 0 && peer_id 2 ; } | sort -u > peers_1_expected && - test_cmp peers_1_expected peers_1_actual - ' - - test_expect_success 'verifying peering for peer 2' ' - list_peers 2 > peers_2_actual && - peer_id 1 > peers_2_expected && - test_cmp peers_2_expected peers_2_actual - ' -} - -test_expect_success 'startup cluster' ' - iptb start -wait && - iptb run -- ipfs log level peering debug -' - -check_peers - -disconnect() { - ipfsi "$1" swarm disconnect "/p2p/$(peer_id "$2")" -} - -# Bidirectional peering shouldn't cause problems (e.g., simultaneous connect -# issues). -test_expect_success 'disconnecting 0->1' ' - disconnect 0 1 -' - -check_peers - -# 1 should reconnect to 2 when 2 disconnects from 1. -test_expect_success 'disconnecting 2->1' ' - disconnect 2 1 -' - -check_peers - -# 2 isn't peering. This test ensures that 1 will re-peer with 2 when it comes -# back online. -test_expect_success 'stopping 2' ' - iptb stop 2 -' - -# Wait to disconnect -sleep 30 - -test_expect_success 'starting 2' ' - iptb start 2 -' - -# Wait for backoff -sleep 30 - -check_peers - -test_expect_success "stop testbed" ' - iptb stop -' - -test_done From cc5e1325b4646e0eb651a63ad04ac86086d2589b Mon Sep 17 00:00:00 2001 From: Jorropo Date: Wed, 15 Mar 2023 03:23:41 +0100 Subject: [PATCH 77/93] chore: deprecate the pubsub api Fixes #9717 --- README.md | 3 +-- cmd/ipfs/daemon.go | 2 +- core/commands/pubsub.go | 20 ++++++++++---------- docs/changelogs/v0.19.md | 7 +++++++ docs/config.md | 12 +++++++++++- docs/experimental-features.md | 31 ------------------------------- 6 files changed, 30 insertions(+), 45 deletions(-) diff --git a/README.md b/README.md index e734fef6642..94e5e42af15 100644 --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ Kubo was the first IPFS implementation and is the most widely used one today. Im Featureset - Runs an IPFS-Node as a network service - [Command Line Interface](https://docs.ipfs.tech/reference/kubo/cli/) to IPFS-Nodes -- Local [Web2-to-Web3 HTTP Gateway functionality](https://github.com/ipfs/specs/tree/main/http-gateways#readme) +- Local [Web2-to-Web3 HTTP Gateway functionality](https://github.com/ipfs/specs/tree/main/http-gateways#readme) - HTTP RPC API (`/api/v0`) to access and control the daemon - IPFS's internal Webgui can be used to manage the Kubo nodes @@ -381,7 +381,6 @@ Some places to get you started on the codebase: - libp2p - libp2p: https://github.com/libp2p/go-libp2p - DHT: https://github.com/libp2p/go-libp2p-kad-dht - - PubSub: https://github.com/libp2p/go-libp2p-pubsub - [IPFS : The `Add` command demystified](https://github.com/ipfs/kubo/tree/master/docs/add-code-flow.md) ### Map of Implemented Subsystems diff --git a/cmd/ipfs/daemon.go b/cmd/ipfs/daemon.go index 880d26b0e42..52addcc072c 100644 --- a/cmd/ipfs/daemon.go +++ b/cmd/ipfs/daemon.go @@ -171,7 +171,7 @@ Headers. cmds.BoolOption(enableGCKwd, "Enable automatic periodic repo garbage collection"), cmds.BoolOption(adjustFDLimitKwd, "Check and raise file descriptor limits if needed").WithDefault(true), cmds.BoolOption(migrateKwd, "If true, assume yes at the migrate prompt. If false, assume no."), - cmds.BoolOption(enablePubSubKwd, "Enable experimental pubsub feature. Overrides Pubsub.Enabled config."), + cmds.BoolOption(enablePubSubKwd, "DEPRECATED"), cmds.BoolOption(enableIPNSPubSubKwd, "Enable IPNS over pubsub. Implicitly enables pubsub, overrides Ipns.UsePubsub config."), cmds.BoolOption(enableMultiplexKwd, "DEPRECATED"), cmds.StringOption(agentVersionSuffix, "Optional suffix to the AgentVersion presented by `ipfs id` and also advertised through BitSwap."), diff --git a/core/commands/pubsub.go b/core/commands/pubsub.go index ef8afcb4458..ee795e07829 100644 --- a/core/commands/pubsub.go +++ b/core/commands/pubsub.go @@ -16,14 +16,14 @@ import ( ) var PubsubCmd = &cmds.Command{ - Status: cmds.Experimental, + Status: cmds.Deprecated, Helptext: cmds.HelpText{ Tagline: "An experimental publish-subscribe system on ipfs.", ShortDescription: ` ipfs pubsub allows you to publish messages to a given topic, and also to subscribe to new messages on a given topic. -EXPERIMENTAL FEATURE +DEPRECATED FEATURE (see https://github.com/ipfs/kubo/issues/9717) It is not intended in its current state to be used in a production environment. To use, the daemon must be run with @@ -46,13 +46,13 @@ type pubsubMessage struct { } var PubsubSubCmd = &cmds.Command{ - Status: cmds.Experimental, + Status: cmds.Deprecated, Helptext: cmds.HelpText{ Tagline: "Subscribe to messages on a given topic.", ShortDescription: ` ipfs pubsub sub subscribes to messages on a given topic. -EXPERIMENTAL FEATURE +DEPRECATED FEATURE (see https://github.com/ipfs/kubo/issues/9717) It is not intended in its current state to be used in a production environment. To use, the daemon must be run with @@ -145,14 +145,14 @@ TOPIC AND DATA ENCODING } var PubsubPubCmd = &cmds.Command{ - Status: cmds.Experimental, + Status: cmds.Deprecated, Helptext: cmds.HelpText{ Tagline: "Publish data to a given pubsub topic.", ShortDescription: ` ipfs pubsub pub publishes a message to a specified topic. It reads binary data from stdin or a file. -EXPERIMENTAL FEATURE +DEPRECATED FEATURE (see https://github.com/ipfs/kubo/issues/9717) It is not intended in its current state to be used in a production environment. To use, the daemon must be run with @@ -201,13 +201,13 @@ HTTP RPC ENCODING } var PubsubLsCmd = &cmds.Command{ - Status: cmds.Experimental, + Status: cmds.Deprecated, Helptext: cmds.HelpText{ Tagline: "List subscribed topics by name.", ShortDescription: ` ipfs pubsub ls lists out the names of topics you are currently subscribed to. -EXPERIMENTAL FEATURE +DEPRECATED FEATURE (see https://github.com/ipfs/kubo/issues/9717) It is not intended in its current state to be used in a production environment. To use, the daemon must be run with @@ -273,7 +273,7 @@ func safeTextListEncoder(req *cmds.Request, w io.Writer, list *stringList) error } var PubsubPeersCmd = &cmds.Command{ - Status: cmds.Experimental, + Status: cmds.Deprecated, Helptext: cmds.HelpText{ Tagline: "List peers we are currently pubsubbing with.", ShortDescription: ` @@ -281,7 +281,7 @@ ipfs pubsub peers with no arguments lists out the pubsub peers you are currently connected to. If given a topic, it will list connected peers who are subscribed to the named topic. -EXPERIMENTAL FEATURE +DEPRECATED FEATURE (see https://github.com/ipfs/kubo/issues/9717) It is not intended in its current state to be used in a production environment. To use, the daemon must be run with diff --git a/docs/changelogs/v0.19.md b/docs/changelogs/v0.19.md index fede7a4547f..12331cae78d 100644 --- a/docs/changelogs/v0.19.md +++ b/docs/changelogs/v0.19.md @@ -8,6 +8,7 @@ - [🔦 Highlights](#-highlights) - [Improving the libp2p resource management integration](#improving-the-libp2p-resource-management-integration) - [Addition of "autoclient" router type](#addition-of-autoclient-router-type) + - [Deprecation of the `ipfs pubsub` commands and matching HTTP endpoints](#deprecation-of-the-ipfs-pubsub-commands-and-matching-http-endpoints) - [📝 Changelog](#-changelog) - [👨‍👩‍👧‍👦 Contributors](#-contributors) @@ -28,6 +29,12 @@ A new routing type "autoclient" has been added. This mode is similar to "auto", See the [Routing.Type documentation](https://github.com/ipfs/kubo/blob/master/docs/config.md#routingtype) for more information. +#### Deprecation of the `ipfs pubsub` commands and matching HTTP endpoints + +We are deprecating `ipfs pubsub` and all `/api/v0/pubsub/` RPC endpoints and will remove them in the next release. + +For more information and rational see [#9717](https://github.com/ipfs/kubo/issues/9717). + ### 📝 Changelog ### 👨‍👩‍👧‍👦 Contributors diff --git a/docs/config.md b/docs/config.md index de47e544511..28331c2aea2 100644 --- a/docs/config.md +++ b/docs/config.md @@ -1165,13 +1165,15 @@ Type: `duration` ## `Pubsub` +**DEPRECATED**: See [#9717](https://github.com/ipfs/kubo/issues/9717) + Pubsub configures the `ipfs pubsub` subsystem. To use, it must be enabled by passing the `--enable-pubsub-experiment` flag to the daemon or via the `Pubsub.Enabled` flag below. ### `Pubsub.Enabled` -**EXPERIMENTAL:** read about current limitations at [experimental-features.md#ipfs-pubsub](./experimental-features.md#ipfs-pubsub). +**DEPRECATED**: See [#9717](https://github.com/ipfs/kubo/issues/9717) Enables the pubsub system. @@ -1181,6 +1183,8 @@ Type: `flag` ### `Pubsub.Router` +**DEPRECATED**: See [#9717](https://github.com/ipfs/kubo/issues/9717) + Sets the default router used by pubsub to route messages to peers. This can be one of: * `"floodsub"` - floodsub is a basic router that simply _floods_ messages to all @@ -1196,6 +1200,8 @@ Type: `string` (one of `"floodsub"`, `"gossipsub"`, or `""` (apply default)) ### `Pubsub.DisableSigning` +**DEPRECATED**: See [#9717](https://github.com/ipfs/kubo/issues/9717) + Disables message signing and signature verification. Enable this option if you're operating in a completely trusted network. @@ -1209,6 +1215,8 @@ Type: `bool` ### `Pubsub.SeenMessagesTTL` +**DEPRECATED**: See [#9717](https://github.com/ipfs/kubo/issues/9717) + Controls the time window within which duplicate messages, identified by Message ID, will be identified and won't be emitted again. @@ -1228,6 +1236,8 @@ Type: `optionalDuration` ### `Pubsub.SeenMessagesStrategy` +**DEPRECATED**: See [#9717](https://github.com/ipfs/kubo/issues/9717) + Determines how the time-to-live (TTL) countdown for deduplicating Pubsub messages is calculated. diff --git a/docs/experimental-features.md b/docs/experimental-features.md index 41e72f1df11..296f6ca1e79 100644 --- a/docs/experimental-features.md +++ b/docs/experimental-features.md @@ -12,7 +12,6 @@ When you add a new experimental feature to kubo or change an experimental feature, you MUST please make a PR updating this document, and link the PR in the above issue. -- [ipfs pubsub](#ipfs-pubsub) - [Raw leaves for unixfs files](#raw-leaves-for-unixfs-files) - [ipfs filestore](#ipfs-filestore) - [ipfs urlstore](#ipfs-urlstore) @@ -31,36 +30,6 @@ the above issue. --- -## ipfs pubsub - -### State - -Candidate, disabled by default but will be enabled by default in 0.6.0. - -### In Version - -0.4.5 (`--enable-pubsub-experiment`) -0.11.0 (`Pubsub.Enabled` flag in config) - -### How to enable - -Run your daemon with the `--enable-pubsub-experiment` flag -or modify your ipfs config and restart the daemon: -``` -ipfs config --json Pubsub.Enabled true -``` - -Then use the `ipfs pubsub` commands. - -NOTE: `--enable-pubsub-experiment` CLI flag overrides `Pubsub.Enabled` config. - -Configuration documentation can be found in [kubo/docs/config.md](./config.md#pubsub) - -### Road to being a real feature - -- [ ] Needs to not impact peers who don't use pubsub: - https://github.com/libp2p/go-libp2p-pubsub/issues/332 - ## Raw Leaves for unixfs files Allows files to be added with no formatting in the leaf nodes of the graph. From c78c9886ad1c647f33846908b4bf01ecc769cb12 Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Wed, 15 Mar 2023 14:57:23 -0400 Subject: [PATCH 78/93] test: fix flaky rcmgr test --- test/cli/rcmgr_test.go | 6 +++++- test/cli/testutils/asserts.go | 15 +++++++++++++++ 2 files changed, 20 insertions(+), 1 deletion(-) create mode 100644 test/cli/testutils/asserts.go diff --git a/test/cli/rcmgr_test.go b/test/cli/rcmgr_test.go index 51b2b0452e3..9d76a7dd81d 100644 --- a/test/cli/rcmgr_test.go +++ b/test/cli/rcmgr_test.go @@ -7,6 +7,7 @@ import ( "github.com/ipfs/kubo/config" "github.com/ipfs/kubo/core/node/libp2p" "github.com/ipfs/kubo/test/cli/harness" + "github.com/ipfs/kubo/test/cli/testutils" "github.com/libp2p/go-libp2p/core/peer" "github.com/libp2p/go-libp2p/core/protocol" rcmgr "github.com/libp2p/go-libp2p/p2p/host/resource-manager" @@ -209,7 +210,10 @@ func TestRcmgr(t *testing.T) { Args: []string{"swarm", "connect", node1.SwarmAddrsWithPeerIDs()[0].String()}, }) assert.Equal(t, 1, res.ExitCode()) - assert.Contains(t, res.Stderr.String(), "failed to find any peer in table") + testutils.AssertStringContainsOneOf(t, res.Stderr.String(), + "failed to find any peer in table", + "resource limit exceeded", + ) res = node0.RunIPFS("ping", "-n2", peerID1) assert.Equal(t, 1, res.ExitCode()) diff --git a/test/cli/testutils/asserts.go b/test/cli/testutils/asserts.go new file mode 100644 index 00000000000..cf840c20ee7 --- /dev/null +++ b/test/cli/testutils/asserts.go @@ -0,0 +1,15 @@ +package testutils + +import ( + "strings" + "testing" +) + +func AssertStringContainsOneOf(t *testing.T, str string, ss ...string) { + for _, s := range ss { + if strings.Contains(str, s) { + return + } + } + t.Errorf("%q does not contain one of %v", str, ss) +} From 6ff764f9fb1bfbff2625f46c732d3515b0443c70 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Wed, 15 Mar 2023 04:40:16 +0100 Subject: [PATCH 79/93] fix: preserve Unlimited StreamsInbound in connmgr reconciliation Fixes #9695 --- core/node/libp2p/rcmgr.go | 4 ++++ core/node/libp2p/rcmgr_defaults.go | 4 +++- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/core/node/libp2p/rcmgr.go b/core/node/libp2p/rcmgr.go index 54bff2852df..3e162453102 100644 --- a/core/node/libp2p/rcmgr.go +++ b/core/node/libp2p/rcmgr.go @@ -459,6 +459,7 @@ func ensureConnMgrMakeSenseVsResourceMgr(concreteLimits rcmgr.ConcreteLimitConfi return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. resource manager System.Conns (%d) must be bigger than ConnMgr.HighWater (%d) +See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.Conns, highWater) } if rcm.System.ConnsInbound != rcmgr.Unlimited && int64(rcm.System.ConnsInbound) <= highWater { @@ -466,6 +467,7 @@ resource manager System.Conns (%d) must be bigger than ConnMgr.HighWater (%d) return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. resource manager System.ConnsInbound (%d) must be bigger than ConnMgr.HighWater (%d) +See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.ConnsInbound, highWater) } if rcm.System.Streams != rcmgr.Unlimited && int64(rcm.System.Streams) <= highWater { @@ -473,6 +475,7 @@ resource manager System.ConnsInbound (%d) must be bigger than ConnMgr.HighWater return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. resource manager System.Streams (%d) must be bigger than ConnMgr.HighWater (%d) +See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.Streams, highWater) } if rcm.System.StreamsInbound != rcmgr.Unlimited && int64(rcm.System.StreamsInbound) <= highWater { @@ -480,6 +483,7 @@ resource manager System.Streams (%d) must be bigger than ConnMgr.HighWater (%d) return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. resource manager System.StreamsInbound (%d) must be bigger than ConnMgr.HighWater (%d) +See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.StreamsInbound, highWater) } return nil diff --git a/core/node/libp2p/rcmgr_defaults.go b/core/node/libp2p/rcmgr_defaults.go index 5faaf7979b3..4f02c6b4a88 100644 --- a/core/node/libp2p/rcmgr_defaults.go +++ b/core/node/libp2p/rcmgr_defaults.go @@ -129,7 +129,9 @@ func createDefaultLimitConfig(cfg config.SwarmConfig) (limitConfig rcmgr.Concret } // Scale System.StreamsInbound as well, but use the existing ratio of StreamsInbound to ConnsInbound - partialLimits.System.StreamsInbound = rcmgr.LimitVal(maxInboundConns * int64(partialLimits.System.StreamsInbound) / int64(partialLimits.System.ConnsInbound)) + if partialLimits.System.StreamsInbound != rcmgr.Unlimited { + partialLimits.System.StreamsInbound = rcmgr.LimitVal(maxInboundConns * int64(partialLimits.System.StreamsInbound) / int64(partialLimits.System.ConnsInbound)) + } partialLimits.System.ConnsInbound = rcmgr.LimitVal(maxInboundConns) } From 383065397deafc7031aaa9ddad69c450400c3e2b Mon Sep 17 00:00:00 2001 From: Jorropo Date: Wed, 15 Mar 2023 17:36:08 +0100 Subject: [PATCH 80/93] test: add test for presarvation of unlimited configs for inbound systems --- test/cli/rcmgr_test.go | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/test/cli/rcmgr_test.go b/test/cli/rcmgr_test.go index 9d76a7dd81d..3dbceb5d7f7 100644 --- a/test/cli/rcmgr_test.go +++ b/test/cli/rcmgr_test.go @@ -127,6 +127,22 @@ func TestRcmgr(t *testing.T) { }) }) + t.Run("smoke test unlimited System inbounds", func(t *testing.T) { + t.Parallel() + node := harness.NewT(t).NewNode().Init() + node.UpdateUserSuppliedResourceManagerOverrides(func(overrides *rcmgr.PartialLimitConfig) { + overrides.System.StreamsInbound = rcmgr.Unlimited + overrides.System.ConnsInbound = rcmgr.Unlimited + }) + node.StartDaemon() + + res := node.RunIPFS("swarm", "resources", "--enc=json") + limits := unmarshalLimits(t, res.Stdout.Bytes()) + + assert.Equal(t, rcmgr.Unlimited, limits.System.ConnsInbound) + assert.Equal(t, rcmgr.Unlimited, limits.System.StreamsInbound) + }) + t.Run("smoke test transient scope", func(t *testing.T) { t.Parallel() node := harness.NewT(t).NewNode().Init() From af79d841dcd1429980d20a5427949f1afea8b11f Mon Sep 17 00:00:00 2001 From: Jorropo Date: Wed, 15 Mar 2023 17:40:12 +0100 Subject: [PATCH 81/93] fix: future proof with > rcmgr.DefaultLimit for new enum rcmgr values --- core/node/libp2p/rcmgr.go | 8 ++++---- core/node/libp2p/rcmgr_defaults.go | 4 ++-- test/cli/rcmgr_test.go | 4 ++-- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/core/node/libp2p/rcmgr.go b/core/node/libp2p/rcmgr.go index 3e162453102..c61f8dcfe56 100644 --- a/core/node/libp2p/rcmgr.go +++ b/core/node/libp2p/rcmgr.go @@ -454,7 +454,7 @@ func ensureConnMgrMakeSenseVsResourceMgr(concreteLimits rcmgr.ConcreteLimitConfi rcm := concreteLimits.ToPartialLimitConfig() highWater := cfg.ConnMgr.HighWater.WithDefault(config.DefaultConnMgrHighWater) - if rcm.System.Conns != rcmgr.Unlimited && int64(rcm.System.Conns) <= highWater { + if (rcm.System.Conns > rcmgr.DefaultLimit || rcm.System.Conns == rcmgr.BlockAllLimit) && int64(rcm.System.Conns) <= highWater { // nolint return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. @@ -462,7 +462,7 @@ resource manager System.Conns (%d) must be bigger than ConnMgr.HighWater (%d) See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.Conns, highWater) } - if rcm.System.ConnsInbound != rcmgr.Unlimited && int64(rcm.System.ConnsInbound) <= highWater { + if (rcm.System.ConnsInbound > rcmgr.DefaultLimit || rcm.System.ConnsInbound == rcmgr.BlockAllLimit) && int64(rcm.System.ConnsInbound) <= highWater { // nolint return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. @@ -470,7 +470,7 @@ resource manager System.ConnsInbound (%d) must be bigger than ConnMgr.HighWater See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.ConnsInbound, highWater) } - if rcm.System.Streams != rcmgr.Unlimited && int64(rcm.System.Streams) <= highWater { + if rcm.System.Streams > rcmgr.DefaultLimit || rcm.System.Streams == rcmgr.BlockAllLimit && int64(rcm.System.Streams) <= highWater { // nolint return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. @@ -478,7 +478,7 @@ resource manager System.Streams (%d) must be bigger than ConnMgr.HighWater (%d) See: https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#how-does-the-resource-manager-resourcemgr-relate-to-the-connection-manager-connmgr `, rcm.System.Streams, highWater) } - if rcm.System.StreamsInbound != rcmgr.Unlimited && int64(rcm.System.StreamsInbound) <= highWater { + if (rcm.System.StreamsInbound > rcmgr.DefaultLimit || rcm.System.StreamsInbound == rcmgr.BlockAllLimit) && int64(rcm.System.StreamsInbound) <= highWater { // nolint return fmt.Errorf(` Unable to initialize libp2p due to conflicting resource manager limit configuration. diff --git a/core/node/libp2p/rcmgr_defaults.go b/core/node/libp2p/rcmgr_defaults.go index 4f02c6b4a88..7a0e5a2823d 100644 --- a/core/node/libp2p/rcmgr_defaults.go +++ b/core/node/libp2p/rcmgr_defaults.go @@ -118,7 +118,7 @@ func createDefaultLimitConfig(cfg config.SwarmConfig) (limitConfig rcmgr.Concret // There are ways to break this, but this should catch most problems already. // We might improve this in the future. // See: https://github.com/ipfs/kubo/issues/9545 - if partialLimits.System.ConnsInbound != rcmgr.Unlimited && cfg.ConnMgr.Type.WithDefault(config.DefaultConnMgrType) != "none" { + if partialLimits.System.ConnsInbound > rcmgr.DefaultLimit && cfg.ConnMgr.Type.WithDefault(config.DefaultConnMgrType) != "none" { maxInboundConns := int64(partialLimits.System.ConnsInbound) if connmgrHighWaterTimesTwo := cfg.ConnMgr.HighWater.WithDefault(config.DefaultConnMgrHighWater) * 2; maxInboundConns < connmgrHighWaterTimesTwo { maxInboundConns = connmgrHighWaterTimesTwo @@ -129,7 +129,7 @@ func createDefaultLimitConfig(cfg config.SwarmConfig) (limitConfig rcmgr.Concret } // Scale System.StreamsInbound as well, but use the existing ratio of StreamsInbound to ConnsInbound - if partialLimits.System.StreamsInbound != rcmgr.Unlimited { + if partialLimits.System.StreamsInbound > rcmgr.DefaultLimit { partialLimits.System.StreamsInbound = rcmgr.LimitVal(maxInboundConns * int64(partialLimits.System.StreamsInbound) / int64(partialLimits.System.ConnsInbound)) } partialLimits.System.ConnsInbound = rcmgr.LimitVal(maxInboundConns) diff --git a/test/cli/rcmgr_test.go b/test/cli/rcmgr_test.go index 3dbceb5d7f7..50ea269793d 100644 --- a/test/cli/rcmgr_test.go +++ b/test/cli/rcmgr_test.go @@ -81,10 +81,10 @@ func TestRcmgr(t *testing.T) { require.Equal(t, 0, res.ExitCode()) limits := unmarshalLimits(t, res.Stdout.Bytes()) - if limits.System.ConnsInbound != rcmgr.Unlimited { + if limits.System.ConnsInbound > rcmgr.DefaultLimit { assert.GreaterOrEqual(t, limits.System.ConnsInbound, 800) } - if limits.System.StreamsInbound != rcmgr.Unlimited { + if limits.System.StreamsInbound > rcmgr.DefaultLimit { assert.GreaterOrEqual(t, limits.System.StreamsInbound, 800) } }) From 3c35a0cdea9a9029fe4740f9f609fa99d5965d92 Mon Sep 17 00:00:00 2001 From: Henrique Dias Date: Thu, 16 Mar 2023 17:21:35 +0100 Subject: [PATCH 82/93] chore: bump go-libipfs@v0.6.2 --- docs/examples/kubo-as-a-library/go.mod | 2 +- docs/examples/kubo-as-a-library/go.sum | 4 ++-- go.mod | 2 +- go.sum | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/examples/kubo-as-a-library/go.mod b/docs/examples/kubo-as-a-library/go.mod index 1c19dd3eb94..d96fa795dd1 100644 --- a/docs/examples/kubo-as-a-library/go.mod +++ b/docs/examples/kubo-as-a-library/go.mod @@ -7,7 +7,7 @@ go 1.18 replace github.com/ipfs/kubo => ./../../.. require ( - github.com/ipfs/go-libipfs v0.6.1 + github.com/ipfs/go-libipfs v0.6.2 github.com/ipfs/interface-go-ipfs-core v0.11.0 github.com/ipfs/kubo v0.0.0-00010101000000-000000000000 github.com/libp2p/go-libp2p v0.26.2 diff --git a/docs/examples/kubo-as-a-library/go.sum b/docs/examples/kubo-as-a-library/go.sum index c927b58d90e..3a08f464a97 100644 --- a/docs/examples/kubo-as-a-library/go.sum +++ b/docs/examples/kubo-as-a-library/go.sum @@ -569,8 +569,8 @@ github.com/ipfs/go-ipld-legacy v0.1.1 h1:BvD8PEuqwBHLTKqlGFTHSwrwFOMkVESEvwIYwR2 github.com/ipfs/go-ipld-legacy v0.1.1/go.mod h1:8AyKFCjgRPsQFf15ZQgDB8Din4DML/fOmKZkkFkrIEg= github.com/ipfs/go-ipns v0.3.0 h1:ai791nTgVo+zTuq2bLvEGmWP1M0A6kGTXUsgv/Yq67A= github.com/ipfs/go-ipns v0.3.0/go.mod h1:3cLT2rbvgPZGkHJoPO1YMJeh6LtkxopCkKFcio/wE24= -github.com/ipfs/go-libipfs v0.6.1 h1:OSO9cm1H3r4OXfP0MP1Q5UhTnhd2fByGl6CVYyz/Rhk= -github.com/ipfs/go-libipfs v0.6.1/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= +github.com/ipfs/go-libipfs v0.6.2 h1:QUf3kS3RrCjgtE0QW2d18PFFfOLeEt24Ft892ipLzRI= +github.com/ipfs/go-libipfs v0.6.2/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk= github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A= diff --git a/go.mod b/go.mod index 673dd3793bd..4fce33b56a6 100644 --- a/go.mod +++ b/go.mod @@ -45,7 +45,7 @@ require ( github.com/ipfs/go-ipld-git v0.1.1 github.com/ipfs/go-ipld-legacy v0.1.1 github.com/ipfs/go-ipns v0.3.0 - github.com/ipfs/go-libipfs v0.6.1 + github.com/ipfs/go-libipfs v0.6.2 github.com/ipfs/go-log v1.0.5 github.com/ipfs/go-log/v2 v2.5.1 github.com/ipfs/go-merkledag v0.9.0 diff --git a/go.sum b/go.sum index 16329d6ad3b..100875344fe 100644 --- a/go.sum +++ b/go.sum @@ -591,8 +591,8 @@ github.com/ipfs/go-ipld-legacy v0.1.1 h1:BvD8PEuqwBHLTKqlGFTHSwrwFOMkVESEvwIYwR2 github.com/ipfs/go-ipld-legacy v0.1.1/go.mod h1:8AyKFCjgRPsQFf15ZQgDB8Din4DML/fOmKZkkFkrIEg= github.com/ipfs/go-ipns v0.3.0 h1:ai791nTgVo+zTuq2bLvEGmWP1M0A6kGTXUsgv/Yq67A= github.com/ipfs/go-ipns v0.3.0/go.mod h1:3cLT2rbvgPZGkHJoPO1YMJeh6LtkxopCkKFcio/wE24= -github.com/ipfs/go-libipfs v0.6.1 h1:OSO9cm1H3r4OXfP0MP1Q5UhTnhd2fByGl6CVYyz/Rhk= -github.com/ipfs/go-libipfs v0.6.1/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= +github.com/ipfs/go-libipfs v0.6.2 h1:QUf3kS3RrCjgtE0QW2d18PFFfOLeEt24Ft892ipLzRI= +github.com/ipfs/go-libipfs v0.6.2/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk= github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A= From 010e22b508153672a777d180e6cdc16f59090b21 Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Thu, 16 Mar 2023 08:41:50 -0400 Subject: [PATCH 83/93] feat: add heap allocs to 'ipfs diag profile' --- core/commands/profile.go | 4 +++- profile/profile.go | 10 ++++++++++ profile/profile_test.go | 6 ++++++ 3 files changed, 19 insertions(+), 1 deletion(-) diff --git a/core/commands/profile.go b/core/commands/profile.go index 3875cfdcba2..d25711dac22 100644 --- a/core/commands/profile.go +++ b/core/commands/profile.go @@ -49,7 +49,8 @@ The output file includes: - A list of running goroutines. - A CPU profile. -- A heap profile. +- A heap inuse profile. +- A heap allocation profile. - A mutex profile. - A block profile. - Your copy of go-ipfs. @@ -79,6 +80,7 @@ However, it could reveal: profile.CollectorGoroutinesPprof, profile.CollectorVersion, profile.CollectorHeap, + profile.CollectorAllocs, profile.CollectorBin, profile.CollectorCPU, profile.CollectorMutex, diff --git a/profile/profile.go b/profile/profile.go index d15d5125140..b9ad86d2f53 100644 --- a/profile/profile.go +++ b/profile/profile.go @@ -22,6 +22,7 @@ const ( CollectorGoroutinesPprof = "goroutines-pprof" CollectorVersion = "version" CollectorHeap = "heap" + CollectorAllocs = "allocs" CollectorBin = "bin" CollectorCPU = "cpu" CollectorMutex = "mutex" @@ -71,6 +72,11 @@ var collectors = map[string]collector{ collectFunc: heapProfile, enabledFunc: func(opts Options) bool { return true }, }, + CollectorAllocs: { + outputFile: "allocs.pprof", + collectFunc: allocsProfile, + enabledFunc: func(opts Options) bool { return true }, + }, CollectorBin: { outputFile: "ipfs", isExecutable: true, @@ -197,6 +203,10 @@ func heapProfile(ctx context.Context, _ Options, w io.Writer) error { return pprof.Lookup("heap").WriteTo(w, 0) } +func allocsProfile(ctx context.Context, _ Options, w io.Writer) error { + return pprof.Lookup("allocs").WriteTo(w, 0) +} + func versionInfo(ctx context.Context, _ Options, w io.Writer) error { return json.NewEncoder(w).Encode(version.GetVersionInfo()) } diff --git a/profile/profile_test.go b/profile/profile_test.go index 8da00d0181a..a2fe0b51d59 100644 --- a/profile/profile_test.go +++ b/profile/profile_test.go @@ -17,6 +17,7 @@ func TestProfiler(t *testing.T) { CollectorGoroutinesPprof, CollectorVersion, CollectorHeap, + CollectorAllocs, CollectorBin, CollectorCPU, CollectorMutex, @@ -43,6 +44,7 @@ func TestProfiler(t *testing.T) { "goroutines.pprof", "version.json", "heap.pprof", + "allocs.pprof", "ipfs", "cpu.pprof", "mutex.pprof", @@ -63,6 +65,7 @@ func TestProfiler(t *testing.T) { "goroutines.pprof", "version.json", "heap.pprof", + "allocs.pprof", "ipfs.exe", "cpu.pprof", "mutex.pprof", @@ -81,6 +84,7 @@ func TestProfiler(t *testing.T) { "goroutines.pprof", "version.json", "heap.pprof", + "allocs.pprof", "ipfs", }, }, @@ -96,6 +100,7 @@ func TestProfiler(t *testing.T) { "goroutines.pprof", "version.json", "heap.pprof", + "allocs.pprof", "ipfs", "cpu.pprof", "block.pprof", @@ -114,6 +119,7 @@ func TestProfiler(t *testing.T) { "goroutines.pprof", "version.json", "heap.pprof", + "allocs.pprof", "ipfs", "cpu.pprof", "mutex.pprof", From 6cdc3c8a144f95d422563930f81c5d7a30a4523a Mon Sep 17 00:00:00 2001 From: Henrique Dias Date: Fri, 17 Mar 2023 15:14:10 +0100 Subject: [PATCH 84/93] fix: apply API.HTTPHeaders to /webui redirect --- core/corehttp/redirect.go | 15 +++++++++++++-- test/cli/gateway_test.go | 17 +++++++++++++++++ 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/core/corehttp/redirect.go b/core/corehttp/redirect.go index bcd536d235b..4b98963e2b7 100644 --- a/core/corehttp/redirect.go +++ b/core/corehttp/redirect.go @@ -8,8 +8,14 @@ import ( ) func RedirectOption(path string, redirect string) ServeOption { - handler := &redirectHandler{redirect} return func(n *core.IpfsNode, _ net.Listener, mux *http.ServeMux) (*http.ServeMux, error) { + cfg, err := n.Repo.Config() + if err != nil { + return nil, err + } + + handler := &redirectHandler{redirect, cfg.API.HTTPHeaders} + if len(path) > 0 { mux.Handle("/"+path+"/", handler) } else { @@ -20,9 +26,14 @@ func RedirectOption(path string, redirect string) ServeOption { } type redirectHandler struct { - path string + path string + headers map[string][]string } func (i *redirectHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { + for k, v := range i.headers { + w.Header()[k] = v + } + http.Redirect(w, r, i.path, http.StatusFound) } diff --git a/test/cli/gateway_test.go b/test/cli/gateway_test.go index a585925a763..d2a90b04ae4 100644 --- a/test/cli/gateway_test.go +++ b/test/cli/gateway_test.go @@ -219,6 +219,23 @@ func TestGateway(t *testing.T) { assert.Contains(t, []int{302, 301}, resp.StatusCode) }) + t.Run("GET /webui/ returns user-specified headers", func(t *testing.T) { + t.Parallel() + + header := "Access-Control-Allow-Origin" + values := []string{"http://localhost:3000", "https://webui.ipfs.io"} + + node := harness.NewT(t).NewNode().Init() + node.UpdateConfig(func(cfg *config.Config) { + cfg.API.HTTPHeaders = map[string][]string{header: values} + }) + node.StartDaemon() + + resp := node.APIClient().DisableRedirects().Get("/webui/") + assert.Equal(t, resp.Headers.Values(header), values) + assert.Contains(t, []int{302, 301}, resp.StatusCode) + }) + t.Run("GET /logs returns logs", func(t *testing.T) { t.Parallel() apiClient := node.APIClient() From a22db797b9794d71147459395b32dad6b1e19125 Mon Sep 17 00:00:00 2001 From: Henrique Dias Date: Fri, 17 Mar 2023 15:29:39 +0100 Subject: [PATCH 85/93] fix: canonicalize user defined headers --- core/corehttp/gateway_writable.go | 2 +- core/corehttp/redirect.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/core/corehttp/gateway_writable.go b/core/corehttp/gateway_writable.go index 89a2973ac23..34cd8438ea7 100644 --- a/core/corehttp/gateway_writable.go +++ b/core/corehttp/gateway_writable.go @@ -30,7 +30,7 @@ type writableGatewayHandler struct { func (i *writableGatewayHandler) addUserHeaders(w http.ResponseWriter) { for k, v := range i.config.Headers { - w.Header()[k] = v + w.Header()[http.CanonicalHeaderKey(k)] = v } } diff --git a/core/corehttp/redirect.go b/core/corehttp/redirect.go index 4b98963e2b7..106355d247d 100644 --- a/core/corehttp/redirect.go +++ b/core/corehttp/redirect.go @@ -32,7 +32,7 @@ type redirectHandler struct { func (i *redirectHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { for k, v := range i.headers { - w.Header()[k] = v + w.Header()[http.CanonicalHeaderKey(k)] = v } http.Redirect(w, r, i.path, http.StatusFound) From 7ea6e321fe0ccffdd76f39c203435ab0254f4205 Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Mon, 20 Mar 2023 09:47:59 +0100 Subject: [PATCH 86/93] chore: update go-libp2p to v0.26.3 (#9737) --- docs/examples/kubo-as-a-library/go.mod | 2 +- docs/examples/kubo-as-a-library/go.sum | 4 ++-- go.mod | 2 +- go.sum | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/examples/kubo-as-a-library/go.mod b/docs/examples/kubo-as-a-library/go.mod index d96fa795dd1..5453ae1d581 100644 --- a/docs/examples/kubo-as-a-library/go.mod +++ b/docs/examples/kubo-as-a-library/go.mod @@ -10,7 +10,7 @@ require ( github.com/ipfs/go-libipfs v0.6.2 github.com/ipfs/interface-go-ipfs-core v0.11.0 github.com/ipfs/kubo v0.0.0-00010101000000-000000000000 - github.com/libp2p/go-libp2p v0.26.2 + github.com/libp2p/go-libp2p v0.26.3 github.com/multiformats/go-multiaddr v0.8.0 ) diff --git a/docs/examples/kubo-as-a-library/go.sum b/docs/examples/kubo-as-a-library/go.sum index 3a08f464a97..6f7e7f253b3 100644 --- a/docs/examples/kubo-as-a-library/go.sum +++ b/docs/examples/kubo-as-a-library/go.sum @@ -730,8 +730,8 @@ github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xS github.com/libp2p/go-libp2p v0.7.4/go.mod h1:oXsBlTLF1q7pxr+9w6lqzS1ILpyHsaBPniVO7zIHGMw= github.com/libp2p/go-libp2p v0.8.1/go.mod h1:QRNH9pwdbEBpx5DTJYg+qxcVaDMAz3Ee/qDKwXujH5o= github.com/libp2p/go-libp2p v0.14.3/go.mod h1:d12V4PdKbpL0T1/gsUNN8DfgMuRPDX8bS2QxCZlwRH0= -github.com/libp2p/go-libp2p v0.26.2 h1:eHEoW/696FP7/6DxOvcrKfTD6Bi0DExxiMSZUJxswA0= -github.com/libp2p/go-libp2p v0.26.2/go.mod h1:x75BN32YbwuY0Awm2Uix4d4KOz+/4piInkp4Wr3yOo8= +github.com/libp2p/go-libp2p v0.26.3 h1:6g/psubqwdaBqNNoidbRKSTBEYgaOuKBhHl8Q5tO+PM= +github.com/libp2p/go-libp2p v0.26.3/go.mod h1:x75BN32YbwuY0Awm2Uix4d4KOz+/4piInkp4Wr3yOo8= github.com/libp2p/go-libp2p-asn-util v0.3.0 h1:gMDcMyYiZKkocGXDQ5nsUQyquC9+H+iLEQHwOCZ7s8s= github.com/libp2p/go-libp2p-asn-util v0.3.0/go.mod h1:B1mcOrKUE35Xq/ASTmQ4tN3LNzVVaMNmq2NACuqyB9w= github.com/libp2p/go-libp2p-autonat v0.1.0/go.mod h1:1tLf2yXxiE/oKGtDwPYWTSYG3PtvYlJmg7NeVtPRqH8= diff --git a/go.mod b/go.mod index 4fce33b56a6..f7237b46a74 100644 --- a/go.mod +++ b/go.mod @@ -67,7 +67,7 @@ require ( github.com/jbenet/go-temp-err-catcher v0.1.0 github.com/jbenet/goprocess v0.1.4 github.com/libp2p/go-doh-resolver v0.4.0 - github.com/libp2p/go-libp2p v0.26.2 + github.com/libp2p/go-libp2p v0.26.3 github.com/libp2p/go-libp2p-http v0.4.0 github.com/libp2p/go-libp2p-kad-dht v0.21.1 github.com/libp2p/go-libp2p-kbucket v0.5.0 diff --git a/go.sum b/go.sum index 100875344fe..27e101e1c8a 100644 --- a/go.sum +++ b/go.sum @@ -760,8 +760,8 @@ github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xS github.com/libp2p/go-libp2p v0.7.4/go.mod h1:oXsBlTLF1q7pxr+9w6lqzS1ILpyHsaBPniVO7zIHGMw= github.com/libp2p/go-libp2p v0.8.1/go.mod h1:QRNH9pwdbEBpx5DTJYg+qxcVaDMAz3Ee/qDKwXujH5o= github.com/libp2p/go-libp2p v0.14.3/go.mod h1:d12V4PdKbpL0T1/gsUNN8DfgMuRPDX8bS2QxCZlwRH0= -github.com/libp2p/go-libp2p v0.26.2 h1:eHEoW/696FP7/6DxOvcrKfTD6Bi0DExxiMSZUJxswA0= -github.com/libp2p/go-libp2p v0.26.2/go.mod h1:x75BN32YbwuY0Awm2Uix4d4KOz+/4piInkp4Wr3yOo8= +github.com/libp2p/go-libp2p v0.26.3 h1:6g/psubqwdaBqNNoidbRKSTBEYgaOuKBhHl8Q5tO+PM= +github.com/libp2p/go-libp2p v0.26.3/go.mod h1:x75BN32YbwuY0Awm2Uix4d4KOz+/4piInkp4Wr3yOo8= github.com/libp2p/go-libp2p-asn-util v0.2.0 h1:rg3+Os8jbnO5DxkC7K/Utdi+DkY3q/d1/1q+8WeNAsw= github.com/libp2p/go-libp2p-asn-util v0.2.0/go.mod h1:WoaWxbHKBymSN41hWSq/lGKJEca7TNm58+gGJi2WsLI= github.com/libp2p/go-libp2p-autonat v0.1.0/go.mod h1:1tLf2yXxiE/oKGtDwPYWTSYG3PtvYlJmg7NeVtPRqH8= From 754264fc08e86ecf777cbaeeee5580b120f84c6c Mon Sep 17 00:00:00 2001 From: Piotr Galar Date: Mon, 20 Mar 2023 11:45:02 +0100 Subject: [PATCH 87/93] Merge pull request #9707 from ipfs/changelog-0.19 docs: 0.19 changelog --- docs/changelogs/v0.19.md | 48 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) diff --git a/docs/changelogs/v0.19.md b/docs/changelogs/v0.19.md index 12331cae78d..67dc57af194 100644 --- a/docs/changelogs/v0.19.md +++ b/docs/changelogs/v0.19.md @@ -7,6 +7,10 @@ - [Overview](#overview) - [🔦 Highlights](#-highlights) - [Improving the libp2p resource management integration](#improving-the-libp2p-resource-management-integration) + - [PubSub message caching improvements](#pubsub-message-caching-improvements) + - [Gateways](#gateways) + - [Signed IPNS Record response format](#signed-ipns-record-response-format) + - [Example fetch and inspect IPNS record](#example-fetch-and-inspect-ipns-record) - [Addition of "autoclient" router type](#addition-of-autoclient-router-type) - [Deprecation of the `ipfs pubsub` commands and matching HTTP endpoints](#deprecation-of-the-ipfs-pubsub-commands-and-matching-http-endpoints) - [📝 Changelog](#-changelog) @@ -24,6 +28,50 @@ and [0.18.1](https://github.com/ipfs/kubo/blob/master/docs/changelogs/v0.18.md#i - Note: we don't expect most users to need these capablities, but they are there if so. 1. [Doc updates](https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md). +#### PubSub message caching improvements + +The PubSub message cache will now [prune messages after TTL is exhausted](https://github.com/ipfs/kubo/blob/master/docs/config.md#pubsubseenmessagesttl), [either based on the last time a message was seen or the first time it was seen](https://github.com/ipfs/kubo/blob/master/docs/config.md#pubsubseenmessagesstrategy). + +#### Gateways + +##### Signed IPNS Record response format + +This release implements [IPIP-351](https://github.com/ipfs/specs/pull/351) and +adds Gateway support for returning signed (verifiable) `ipns-record` (0x0300) +when `/ipns/{libp2p-key}` is requested with either +`Accept: application/vnd.ipfs.ipns-record` HTTP header +or `?format=ipns-record` URL query parameter. + + +The Gateway in Kubo already supported [trustless, verifiable retrieval](https://docs.ipfs.tech/reference/http/gateway/#trustless-verifiable-retrieval) of immutable `/ipfs/` namespace. +With `?format=ipns-record`, light HTTP clients are now able to get the same level of verifiability for IPNS websites. + +Tooling is limited at the moment, but we are working on [go-libipfs](https://github.com/ipfs/go-libipfs/) examples that illustrate the verifiable HTTP client pattern. + +##### Example: fetch IPNS record over HTTP and inspect it with `ipfs name inspect --verify` + +```console +$ FILE_CID=$(echo "Hello IPFS" | ipfs add --cid-version 1 -q) +$ IPNS_KEY=$(ipfs key gen test) +$ ipfs name publish /ipfs/$FILE_CID --key=test --ttl=30m +Published to k51q..dvf1: /ipfs/bafk..z244 +$ curl "http://127.0.0.1:8080/ipns/$IPNS_KEY?format=ipns-record" > signed.ipns-record +$ ipfs name inspect --verify $IPNS_KEY < signed.ipns-record +Value: "/ipfs/bafk..." +Validity Type: "EOL" +Validity: 2023-03-09T23:13:34.032977468Z +Sequence: 0 +TTL: 1800000000000 +PublicKey: "" +Signature V1: "m..." +Signature V2: "m..." +Data: {...} + +Validation results: + Valid: true + PublicKey: 12D3... +``` + #### Addition of "autoclient" router type A new routing type "autoclient" has been added. This mode is similar to "auto", in that it is a hybrid of content routers (including Kademlia and HTTP routers), but it does not run a DHT server. This is similar to the difference between "dhtclient" and "dht" router types. From 822106134af70eb56101e123aaf85e0b59b5f3be Mon Sep 17 00:00:00 2001 From: galargh Date: Mon, 20 Mar 2023 11:15:40 +0000 Subject: [PATCH 88/93] chore: update version --- version.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/version.go b/version.go index 71912f891d6..18bbf9a2d33 100644 --- a/version.go +++ b/version.go @@ -11,7 +11,7 @@ import ( var CurrentCommit string // CurrentVersionNumber is the current application's version literal -const CurrentVersionNumber = "0.19.0-rc1" +const CurrentVersionNumber = "0.19.0" const ApiVersion = "/kubo/" + CurrentVersionNumber + "/" //nolint From c9fc10dafcf8487245f83f1e57cd2e02f88dbb51 Mon Sep 17 00:00:00 2001 From: Jorropo Date: Mon, 20 Mar 2023 12:23:16 +0100 Subject: [PATCH 89/93] fix: remove outdated changelog part --- docs/changelogs/v0.19.md | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/docs/changelogs/v0.19.md b/docs/changelogs/v0.19.md index 67dc57af194..5ecb2d0f1c6 100644 --- a/docs/changelogs/v0.19.md +++ b/docs/changelogs/v0.19.md @@ -7,7 +7,6 @@ - [Overview](#overview) - [🔦 Highlights](#-highlights) - [Improving the libp2p resource management integration](#improving-the-libp2p-resource-management-integration) - - [PubSub message caching improvements](#pubsub-message-caching-improvements) - [Gateways](#gateways) - [Signed IPNS Record response format](#signed-ipns-record-response-format) - [Example fetch and inspect IPNS record](#example-fetch-and-inspect-ipns-record) @@ -21,16 +20,13 @@ ### 🔦 Highlights #### Improving the libp2p resource management integration + There are further followups up on libp2p resource manager improvements in Kubo [0.18.0](https://github.com/ipfs/kubo/blob/master/docs/changelogs/v0.18.md#improving-libp2p-resource-management-integration-1) and [0.18.1](https://github.com/ipfs/kubo/blob/master/docs/changelogs/v0.18.md#improving-libp2p-resource-management-integration): 1. `ipfs swarm limits` and `ipfs swarm stats` have been replaced by `ipfs swarm resources` to provide a single/combined view for limits and their current usage in a more intuitive ordering. 1. Removal of `Swarm.ResourceMgr.Limits` config. Instead [the power user can specify limits in a .json file that are fed directly to go-libp2p](https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#user-supplied-override-limits). This allows the power user to take advantage of the [new resource manager types introduced in go-libp2p 0.25](https://github.com/libp2p/go-libp2p/blob/master/CHANGELOG.md#new-resource-manager-types-) including "use default", "unlimited", "block all". - Note: we don't expect most users to need these capablities, but they are there if so. -1. [Doc updates](https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md). - -#### PubSub message caching improvements - -The PubSub message cache will now [prune messages after TTL is exhausted](https://github.com/ipfs/kubo/blob/master/docs/config.md#pubsubseenmessagesttl), [either based on the last time a message was seen or the first time it was seen](https://github.com/ipfs/kubo/blob/master/docs/config.md#pubsubseenmessagesstrategy). +1. [Doc updates](https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md). #### Gateways From 13865920d835ea104be4d803eb2453de0fa42f11 Mon Sep 17 00:00:00 2001 From: galargh Date: Mon, 20 Mar 2023 12:33:11 +0100 Subject: [PATCH 90/93] docs: update changelog --- docs/changelogs/v0.19.md | 467 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 465 insertions(+), 2 deletions(-) diff --git a/docs/changelogs/v0.19.md b/docs/changelogs/v0.19.md index 67dc57af194..4663d132389 100644 --- a/docs/changelogs/v0.19.md +++ b/docs/changelogs/v0.19.md @@ -23,10 +23,10 @@ #### Improving the libp2p resource management integration There are further followups up on libp2p resource manager improvements in Kubo [0.18.0](https://github.com/ipfs/kubo/blob/master/docs/changelogs/v0.18.md#improving-libp2p-resource-management-integration-1) and [0.18.1](https://github.com/ipfs/kubo/blob/master/docs/changelogs/v0.18.md#improving-libp2p-resource-management-integration): -1. `ipfs swarm limits` and `ipfs swarm stats` have been replaced by `ipfs swarm resources` to provide a single/combined view for limits and their current usage in a more intuitive ordering. +1. `ipfs swarm limits` and `ipfs swarm stats` have been replaced by `ipfs swarm resources` to provide a single/combined view for limits and their current usage in a more intuitive ordering. 1. Removal of `Swarm.ResourceMgr.Limits` config. Instead [the power user can specify limits in a .json file that are fed directly to go-libp2p](https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md#user-supplied-override-limits). This allows the power user to take advantage of the [new resource manager types introduced in go-libp2p 0.25](https://github.com/libp2p/go-libp2p/blob/master/CHANGELOG.md#new-resource-manager-types-) including "use default", "unlimited", "block all". - Note: we don't expect most users to need these capablities, but they are there if so. -1. [Doc updates](https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md). +1. [Doc updates](https://github.com/ipfs/kubo/blob/master/docs/libp2p-resource-management.md). #### PubSub message caching improvements @@ -85,4 +85,467 @@ For more information and rational see [#9717](https://github.com/ipfs/kubo/issue ### 📝 Changelog +

Full Changelog + +- github.com/ipfs/kubo: + - chore: update version + - docs: 0.19 changelog ([ipfs/kubo#9707](https://github.com/ipfs/kubo/pull/9707)) + - fix: canonicalize user defined headers + - fix: apply API.HTTPHeaders to /webui redirect + - feat: add heap allocs to 'ipfs diag profile' + - fix: future proof with > rcmgr.DefaultLimit for new enum rcmgr values + - test: add test for presarvation of unlimited configs for inbound systems + - fix: preserve Unlimited StreamsInbound in connmgr reconciliation + - test: fix flaky rcmgr test + - chore: deprecate the pubsub api + - test: port peering test from sharness to Go + - test: use `T.TempDir` to create temporary test directory + - fix: --verify forgets the verified key + - test: name --verify forgets the verified key + - feat: add "autoclient" routing type + - test: parallelize more of rcmgr Go tests + - test: port legacy DHT tests to Go + - fix: t0116-gateway-cache.sh ([ipfs/kubo#9696](https://github.com/ipfs/kubo/pull/9696)) + - docs: add bifrost to early testers ([ipfs/kubo#9699](https://github.com/ipfs/kubo/pull/9699)) + - fix: typo in documentation for install path + - chore: update version + - feat: Reduce RM code footprint + - Doc updates/additions + - ci: replace junit html generation with gh action + - test: port rcmgr sharness tests to Go + - test(gateway): use deterministic CAR fixtures ([ipfs/kubo#9657](https://github.com/ipfs/kubo/pull/9657)) + - feat(gateway): error handling improvements (500, 502, 504) (#9660) ([ipfs/kubo#9660](https://github.com/ipfs/kubo/pull/9660)) + - docs: be clear about swarm.addrfilters (#9661) ([ipfs/kubo#9661](https://github.com/ipfs/kubo/pull/9661)) + - chore: update go-libp2p to v0.26 (#9656) ([ipfs/kubo#9656](https://github.com/ipfs/kubo/pull/9656)) + - feat(pinning): connect some missing go context (#9557) ([ipfs/kubo#9557](https://github.com/ipfs/kubo/pull/9557)) + - fix(gateway): return HTTP 500 on ErrResolveFailed (#9589) ([ipfs/kubo#9589](https://github.com/ipfs/kubo/pull/9589)) + - docs: bulk spelling edits (#9544) ([ipfs/kubo#9544](https://github.com/ipfs/kubo/pull/9544)) + - docs: "remote" errors from resource manager (#9653) ([ipfs/kubo#9653](https://github.com/ipfs/kubo/pull/9653)) + - test: remove gateway tests migrated to go-libipfs + - fix: update rcmgr for go-libp2p v0.25 + - chore: update go-libp2p to v0.25.1 + - docs(0.18.1): guide users to clean up limits (#9644) ([ipfs/kubo#9644](https://github.com/ipfs/kubo/pull/9644)) + - feat: add NewOptionalInteger function + - fix: dereference int64 pointer in OptionalInteger.String() (#9640) ([ipfs/kubo#9640](https://github.com/ipfs/kubo/pull/9640)) + - fix: restore wire format for /api/v0/routing/get|put (#9639) ([ipfs/kubo#9639](https://github.com/ipfs/kubo/pull/9639)) + - refactor(gw): move Host (DNSLink and subdomain) handling to go-libipfs (#9624) ([ipfs/kubo#9624](https://github.com/ipfs/kubo/pull/9624)) + - refactor: new go-libipfs/gateway API, deprecate Gateway.Writable (#9616) ([ipfs/kubo#9616](https://github.com/ipfs/kubo/pull/9616)) + - Create Changelog: v0.19 ([ipfs/kubo#9617](https://github.com/ipfs/kubo/pull/9617)) + - refactor: use gateway from go-libipfs (#9588) ([ipfs/kubo#9588](https://github.com/ipfs/kubo/pull/9588)) + - Merge Release: v0.18.1 ([ipfs/kubo#9613](https://github.com/ipfs/kubo/pull/9613)) + - Add overview section + - Adjust inbound connection limits depending on memory. + - feat: ipfs-webui 2.22.0 + - chore: bump go-libipfs remove go-bitswap + - docs: DefaultResourceMgrMinInboundConns + - feat(gateway): IPNS record response format (IPIP-351) (#9399) ([ipfs/kubo#9399](https://github.com/ipfs/kubo/pull/9399)) + - fix(ipns): honour --ttl flag in 'ipfs name publish' (#9471) ([ipfs/kubo#9471](https://github.com/ipfs/kubo/pull/9471)) + - feat: Pubsub.SeenMessagesStrategy (#9543) ([ipfs/kubo#9543](https://github.com/ipfs/kubo/pull/9543)) + - chore: bump go-libipfs to replace go-block-format + - Merge Kubo: v0.18 ([ipfs/kubo#9581](https://github.com/ipfs/kubo/pull/9581)) + - fix: clarity: no user supplied rcmgr limits of 0 (#9563) ([ipfs/kubo#9563](https://github.com/ipfs/kubo/pull/9563)) + - fix(gateway): undesired conversions to dag-json and friends (#9566) ([ipfs/kubo#9566](https://github.com/ipfs/kubo/pull/9566)) + - fix: ensure connmgr is smaller then autoscalled ressource limits + - fix: typo in ensureConnMgrMakeSenseVsResourcesMgr + - docs: clarify browser descriptions for webtransport + - fix: update saxon download path + - fix: refuse to start if connmgr is smaller than ressource limits and not using none connmgr + - fix: User-Agent sent to HTTP routers + - test: port gateway sharness tests to Go tests + - fix: do not download saxon in parallel + - docs: improve docs/README (#9539) ([ipfs/kubo#9539](https://github.com/ipfs/kubo/pull/9539)) + - test: port CircleCI to GH Actions and improve sharness reporting (#9355) ([ipfs/kubo#9355](https://github.com/ipfs/kubo/pull/9355)) + - chore: migrate from go-ipfs-files to go-libipfs/files (#9535) ([ipfs/kubo#9535](https://github.com/ipfs/kubo/pull/9535)) + - fix: stats dht command when Routing.Type=auto (#9538) ([ipfs/kubo#9538](https://github.com/ipfs/kubo/pull/9538)) + - fix: hint people to changing from RSA peer ids + - fix(gateway): JSON when Accept is a list + - fix(test): retry flaky t0125-twonode.sh + - docs: fix Router config Godoc (#9528) ([ipfs/kubo#9528](https://github.com/ipfs/kubo/pull/9528)) + - fix(ci): flaky sharness test + - docs(config): ProviderSearchDelay (#9526) ([ipfs/kubo#9526](https://github.com/ipfs/kubo/pull/9526)) + - docs: clarify debug environment variables + - fix: disable provide over HTTP with Routing.Type=auto (#9511) ([ipfs/kubo#9511](https://github.com/ipfs/kubo/pull/9511)) + - fix(test): stabilize flaky provider tests + - feat: port pins CLI test + - Removing QRI from early tester ([ipfs/kubo#9503](https://github.com/ipfs/kubo/pull/9503)) + - Update Version (dev): v0.18 ([ipfs/kubo#9500](https://github.com/ipfs/kubo/pull/9500)) +- github.com/ipfs/go-bitfield (v1.0.0 -> v1.1.0): + - Merge pull request from GHSA-2h6c-j3gf-xp9r + - sync: update CI config files (#3) ([ipfs/go-bitfield#3](https://github.com/ipfs/go-bitfield/pull/3)) +- github.com/ipfs/go-block-format (v0.0.3 -> v0.1.1): + - chore: release v0.1.1 + - docs: fix wrong copy paste in docs + - chore: release v0.1.0 + - refactor: deprecate and add stub types to go-libipfs/blocks + - sync: update CI config files (#34) ([ipfs/go-block-format#34](https://github.com/ipfs/go-block-format/pull/34)) + - remove Makefile ([ipfs/go-block-format#31](https://github.com/ipfs/go-block-format/pull/31)) +- github.com/ipfs/go-ipfs-files (v0.0.8 -> v0.3.0): + - ([ipfs/go-ipfs-files#59](https://github.com/ipfs/go-ipfs-files/pull/59)) + - docs: add moved noticed [ci skip] + - Release v0.2.0 + - fix: error when TAR has files outside of root (#56) ([ipfs/go-ipfs-files#56](https://github.com/ipfs/go-ipfs-files/pull/56)) + - sync: update CI config files ([ipfs/go-ipfs-files#55](https://github.com/ipfs/go-ipfs-files/pull/55)) + - chore(Directory): add DirIterator API restriction: iterate only once + - Release v0.1.1 + - fix: add dragonfly build option for filewriter flags + - fix: add freebsd build option for filewriter flags + - Release v0.1.0 + - docs: fix community CONTRIBUTING.md link (#45) ([ipfs/go-ipfs-files#45](https://github.com/ipfs/go-ipfs-files/pull/45)) + - chore(filewriter): cleanup writes (#43) ([ipfs/go-ipfs-files#43](https://github.com/ipfs/go-ipfs-files/pull/43)) + - sync: update CI config files (#44) ([ipfs/go-ipfs-files#44](https://github.com/ipfs/go-ipfs-files/pull/44)) + - sync: update CI config files ([ipfs/go-ipfs-files#40](https://github.com/ipfs/go-ipfs-files/pull/40)) + - fix: manually parse the content disposition to preserve directories ([ipfs/go-ipfs-files#42](https://github.com/ipfs/go-ipfs-files/pull/42)) + - fix: round timestamps down by truncating them to seconds ([ipfs/go-ipfs-files#41](https://github.com/ipfs/go-ipfs-files/pull/41)) + - sync: update CI config files ([ipfs/go-ipfs-files#34](https://github.com/ipfs/go-ipfs-files/pull/34)) + - Fix test failure on Windows caused by nil `sys` in mock `FileInfo` ([ipfs/go-ipfs-files#39](https://github.com/ipfs/go-ipfs-files/pull/39)) + - fix staticcheck ([ipfs/go-ipfs-files#35](https://github.com/ipfs/go-ipfs-files/pull/35)) + - fix linters ([ipfs/go-ipfs-files#33](https://github.com/ipfs/go-ipfs-files/pull/33)) +- github.com/ipfs/go-ipfs-pinner (v0.2.1 -> v0.3.0): + - chore: release v0.3.0 (#27) ([ipfs/go-ipfs-pinner#27](https://github.com/ipfs/go-ipfs-pinner/pull/27)) + - feat!: add and connect missing context, remove RemovePinWithMode (#23) ([ipfs/go-ipfs-pinner#23](https://github.com/ipfs/go-ipfs-pinner/pull/23)) + - sync: update CI config files ([ipfs/go-ipfs-pinner#16](https://github.com/ipfs/go-ipfs-pinner/pull/16)) +- github.com/ipfs/go-ipfs-pq (v0.0.2 -> v0.0.3): + - chore: release v0.0.3 + - fix: enable early GC + - sync: update CI config files (#10) ([ipfs/go-ipfs-pq#10](https://github.com/ipfs/go-ipfs-pq/pull/10)) + - sync: update CI config files ([ipfs/go-ipfs-pq#8](https://github.com/ipfs/go-ipfs-pq/pull/8)) + - remove Makefile ([ipfs/go-ipfs-pq#7](https://github.com/ipfs/go-ipfs-pq/pull/7)) +- github.com/ipfs/go-libipfs (v0.2.0 -> v0.6.2): + - chore: release 0.6.2 (#211) ([ipfs/go-libipfs#211](https://github.com/ipfs/go-libipfs/pull/211)) + - fix(gateway): 500 on panic, recover on WithHostname + - refactor: use assert in remaining gateway tests + - chore: release 0.6.1 + - feat: support HTTP 429 with Retry-After (#194) ([ipfs/go-libipfs#194](https://github.com/ipfs/go-libipfs/pull/194)) + - docs: fix typo in README.md + - fix(gateway): return 500 for all /ip[nf]s/id failures + - chore: make gocritic happier + - feat(gateway): improved error handling, support for 502 and 504 ([ipfs/go-libipfs#182](https://github.com/ipfs/go-libipfs/pull/182)) + - feat: add content path in request context (#184) ([ipfs/go-libipfs#184](https://github.com/ipfs/go-libipfs/pull/184)) + - sync: update CI config files ([ipfs/go-libipfs#159](https://github.com/ipfs/go-libipfs/pull/159)) + - fix(gateway): return HTTP 500 on namesys.ErrResolveFailed (#150) ([ipfs/go-libipfs#150](https://github.com/ipfs/go-libipfs/pull/150)) + - docs(examples): add UnixFS file download over Bitswap (#143) ([ipfs/go-libipfs#143](https://github.com/ipfs/go-libipfs/pull/143)) + - bitswap/server/internal/decision: fix: remove unused private type + - chore: release v0.6.0 + - bitswap/server/internal/decision: add more non flaky tests + - bitswap/server/internal/decision: add filtering on CIDs - Ignore cids that are too big. - Kill connection for peers that are using inline CIDs. + - bitswap/server/internal/decision: rewrite ledger inversion + - docs(readme): various updates for clarity (#171) ([ipfs/go-libipfs#171](https://github.com/ipfs/go-libipfs/pull/171)) + - feat: metric for implicit index.html in dirs + - fix(gateway): ensure ipfs_http_gw_get_duration_seconds gets updated + - test(gateway): migrate Go tests from Kubo ([ipfs/go-libipfs#156](https://github.com/ipfs/go-libipfs/pull/156)) + - docs: fix link (#165) ([ipfs/go-libipfs#165](https://github.com/ipfs/go-libipfs/pull/165)) + - fix: GetIPNSRecord example gateway implementation (#158) ([ipfs/go-libipfs#158](https://github.com/ipfs/go-libipfs/pull/158)) + - chore: release v0.5.0 + - chore: update go-libp2p to v0.25.1 + - fix(gateway): display correct error with 500 (#160) ([ipfs/go-libipfs#160](https://github.com/ipfs/go-libipfs/pull/160)) + - fix: gateway car example dnslink + - feat(gateway): add TAR, IPNS Record, DAG-* histograms and spans (#155) ([ipfs/go-libipfs#155](https://github.com/ipfs/go-libipfs/pull/155)) + - feat(gateway): migrate subdomain and dnslink code (#153) ([ipfs/go-libipfs#153](https://github.com/ipfs/go-libipfs/pull/153)) + - docs: add example of gateway that proxies to ?format=raw (#151) ([ipfs/go-libipfs#151](https://github.com/ipfs/go-libipfs/pull/151)) + - docs: add example of gateway backed by CAR file (#147) ([ipfs/go-libipfs#147](https://github.com/ipfs/go-libipfs/pull/147)) + - undefined ([ipfs/go-libipfs#145](https://github.com/ipfs/go-libipfs/pull/145)) + - Extract Gateway Code From Kubo + ([ipfs/go-libipfs#65](https://github.com/ipfs/go-libipfs/pull/65)) + - Migrate go-bitswap ([ipfs/go-libipfs#63](https://github.com/ipfs/go-libipfs/pull/63)) + - Use `PUT` as method to insert provider records + - Migrate `go-block-format` ([ipfs/go-libipfs#58](https://github.com/ipfs/go-libipfs/pull/58)) + - chore: add codecov PR comment + - chore: add a logo and some basics in the README (#37) ([ipfs/go-libipfs#37](https://github.com/ipfs/go-libipfs/pull/37)) +- github.com/ipfs/go-namesys (v0.6.0 -> v0.7.0): + - chore: release 0.7.0 (#36) ([ipfs/go-namesys#36](https://github.com/ipfs/go-namesys/pull/36)) + - feat: use PublishOptions for publishing IPNS records (#35) ([ipfs/go-namesys#35](https://github.com/ipfs/go-namesys/pull/35)) +- github.com/ipfs/go-path (v0.3.0 -> v0.3.1): + - chore: release v0.3.1 (#67) ([ipfs/go-path#67](https://github.com/ipfs/go-path/pull/67)) + - feat: expose ErrInvalidPath and implement .Is function (#66) ([ipfs/go-path#66](https://github.com/ipfs/go-path/pull/66)) + - sync: update CI config files (#60) ([ipfs/go-path#60](https://github.com/ipfs/go-path/pull/60)) + - feat: add basic tracing ([ipfs/go-path#59](https://github.com/ipfs/go-path/pull/59)) +- github.com/ipfs/go-peertaskqueue (v0.8.0 -> v0.8.1): + - chore: release v0.8.1 + - feat: add PushTasksTruncated which only push a limited amount of tasks + - feat: add (*PeerTaskQueue).Clear which fully removes a peer + - sync: update CI config files (#26) ([ipfs/go-peertaskqueue#26](https://github.com/ipfs/go-peertaskqueue/pull/26)) +- github.com/ipfs/go-unixfs (v0.4.2 -> v0.4.4): + - chore: release v0.4.4 + - fix: correctly handle return errors + - fix: correctly handle errors in balancedbuilder's Layout + - test: fix tests after hamt issues fixes + - Merge pull request from GHSA-q264-w97q-q778 +- github.com/ipfs/go-unixfsnode (v1.5.1 -> v1.5.2): + - Merge pull request from GHSA-4gj3-6r43-3wfc +- github.com/ipfs/interface-go-ipfs-core (v0.8.2 -> v0.11.0): + - chore: release v0.11.0 + - test: basic routing interface test + - chore: release v0.10.0 (#102) ([ipfs/interface-go-ipfs-core#102](https://github.com/ipfs/interface-go-ipfs-core/pull/102)) + - feat: add RoutingAPI to CoreAPI + - chore: release 0.9.0 (#101) ([ipfs/interface-go-ipfs-core#101](https://github.com/ipfs/interface-go-ipfs-core/pull/101)) + - feat: add namesys publish options (#94) ([ipfs/interface-go-ipfs-core#94](https://github.com/ipfs/interface-go-ipfs-core/pull/94)) +- github.com/ipld/go-car (v0.4.0 -> v0.5.0): + - chore: bump version to 0.5.0 + - fix: remove use of ioutil + - run gofmt -s + - bump go.mod to Go 1.18 and run go fix + - bump go.mod to Go 1.18 and run go fix + - OpenReadWriteFile: add test + - blockstore: allow to pass a file to write in (#323) ([ipld/go-car#323](https://github.com/ipld/go-car/pull/323)) + - feat: add `car inspect` command to cmd pkg (#320) ([ipld/go-car#320](https://github.com/ipld/go-car/pull/320)) + - Separate `index.ReadFrom` tests + - Only read index codec during inspection + - Upgrade to the latest `go-car/v2` + - Empty identity CID should be indexed when options are set +- github.com/libp2p/go-libp2p (v0.24.2 -> v0.26.3): + - Release v0.26.3 (#2197) ([libp2p/go-libp2p#2197](https://github.com/libp2p/go-libp2p/pull/2197)) + - retract v0.26.1, release v0.26.2 (#2153) ([libp2p/go-libp2p#2153](https://github.com/libp2p/go-libp2p/pull/2153)) + - rcmgr: fix JSON marshalling of ResourceManagerStat peer map (#2156) ([libp2p/go-libp2p#2156](https://github.com/libp2p/go-libp2p/pull/2156)) + - release v0.26.1 ([libp2p/go-libp2p#2146](https://github.com/libp2p/go-libp2p/pull/2146)) + - release v0.26.0 (#2133) ([libp2p/go-libp2p#2133](https://github.com/libp2p/go-libp2p/pull/2133)) + - identify: add more detailed metrics (#2126) ([libp2p/go-libp2p#2126](https://github.com/libp2p/go-libp2p/pull/2126)) + - autorelay: refactor relay finder and start autorelay after identify (#2120) ([libp2p/go-libp2p#2120](https://github.com/libp2p/go-libp2p/pull/2120)) + - don't use the time value from the time.Ticker channel (#2127) ([libp2p/go-libp2p#2127](https://github.com/libp2p/go-libp2p/pull/2127)) + - Wrap conn with metrics (#2131) ([libp2p/go-libp2p#2131](https://github.com/libp2p/go-libp2p/pull/2131)) + - chore: update changelog for 0.26.0 (#2132) ([libp2p/go-libp2p#2132](https://github.com/libp2p/go-libp2p/pull/2132)) + - circuitv2: Update proto files to proto3 (#2121) ([libp2p/go-libp2p#2121](https://github.com/libp2p/go-libp2p/pull/2121)) + - swarm: remove parallel tests from swarm tests (#2130) ([libp2p/go-libp2p#2130](https://github.com/libp2p/go-libp2p/pull/2130)) + - circuitv2: add a relay option to disable limits (#2125) ([libp2p/go-libp2p#2125](https://github.com/libp2p/go-libp2p/pull/2125)) + - quic: fix stalled virtual listener (#2122) ([libp2p/go-libp2p#2122](https://github.com/libp2p/go-libp2p/pull/2122)) + - swarm: add early muxer selection to swarm metrics (#2119) ([libp2p/go-libp2p#2119](https://github.com/libp2p/go-libp2p/pull/2119)) + - metrics: add options to disable metrics and to set Prometheus registerer (#2116) ([libp2p/go-libp2p#2116](https://github.com/libp2p/go-libp2p/pull/2116)) + - swarm: add ip_version to metrics (#2114) ([libp2p/go-libp2p#2114](https://github.com/libp2p/go-libp2p/pull/2114)) + - Revert mistaken "Bump timeout" + - Bump timeout + - remove all circuit v1 related code (#2107) ([libp2p/go-libp2p#2107](https://github.com/libp2p/go-libp2p/pull/2107)) + - quic: don't send detailed error messages when closing connections (#2112) ([libp2p/go-libp2p#2112](https://github.com/libp2p/go-libp2p/pull/2112)) + - metrics: add no alloc metrics for eventbus, swarm, identify (#2108) ([libp2p/go-libp2p#2108](https://github.com/libp2p/go-libp2p/pull/2108)) + - chore: fix typo in Changelog (#2111) ([libp2p/go-libp2p#2111](https://github.com/libp2p/go-libp2p/pull/2111)) + - chore: update changelog (#2109) ([libp2p/go-libp2p#2109](https://github.com/libp2p/go-libp2p/pull/2109)) + - chore: unify dashboard location (#2110) ([libp2p/go-libp2p#2110](https://github.com/libp2p/go-libp2p/pull/2110)) + - autonat: add metrics (#2086) ([libp2p/go-libp2p#2086](https://github.com/libp2p/go-libp2p/pull/2086)) + - relaymanager: do not start new relay if one already exists (#2093) ([libp2p/go-libp2p#2093](https://github.com/libp2p/go-libp2p/pull/2093)) + - autonat: don't emit reachability changed events on address change (#2092) ([libp2p/go-libp2p#2092](https://github.com/libp2p/go-libp2p/pull/2092)) + - chore: modify changelog entries (#2101) ([libp2p/go-libp2p#2101](https://github.com/libp2p/go-libp2p/pull/2101)) + - Introduce a changelog (#2084) ([libp2p/go-libp2p#2084](https://github.com/libp2p/go-libp2p/pull/2084)) + - use atomic.Int32 and atomic.Int64 (#2096) ([libp2p/go-libp2p#2096](https://github.com/libp2p/go-libp2p/pull/2096)) + - change atomic.Value to atomic.Pointer (#2088) ([libp2p/go-libp2p#2088](https://github.com/libp2p/go-libp2p/pull/2088)) + - use atomic.Bool instead of int32 operations (#2089) ([libp2p/go-libp2p#2089](https://github.com/libp2p/go-libp2p/pull/2089)) + - sync: update CI config files (#2073) ([libp2p/go-libp2p#2073](https://github.com/libp2p/go-libp2p/pull/2073)) + - chore: update examples to v0.25.1 (#2080) ([libp2p/go-libp2p#2080](https://github.com/libp2p/go-libp2p/pull/2080)) + - v0.25.1 (#2082) ([libp2p/go-libp2p#2082](https://github.com/libp2p/go-libp2p/pull/2082)) + - Start host in mocknet (#2078) ([libp2p/go-libp2p#2078](https://github.com/libp2p/go-libp2p/pull/2078)) + - Release v0.25.0 (#2077) ([libp2p/go-libp2p#2077](https://github.com/libp2p/go-libp2p/pull/2077)) + - identify: add some basic metrics (#2069) ([libp2p/go-libp2p#2069](https://github.com/libp2p/go-libp2p/pull/2069)) + - p2p/test/quic: use contexts with a timeout for Connect calls (#2070) ([libp2p/go-libp2p#2070](https://github.com/libp2p/go-libp2p/pull/2070)) + - feat!: rcmgr: Change LimitConfig to use LimitVal type (#2000) ([libp2p/go-libp2p#2000](https://github.com/libp2p/go-libp2p/pull/2000)) + - identify: refactor sending of Identify pushes (#1984) ([libp2p/go-libp2p#1984](https://github.com/libp2p/go-libp2p/pull/1984)) + - Update interop to match spec (#2049) ([libp2p/go-libp2p#2049](https://github.com/libp2p/go-libp2p/pull/2049)) + - chore: git-ignore various flavors of qlog files (#2064) ([libp2p/go-libp2p#2064](https://github.com/libp2p/go-libp2p/pull/2064)) + - rcmgr: add libp2p prefix to all metrics (#2063) ([libp2p/go-libp2p#2063](https://github.com/libp2p/go-libp2p/pull/2063)) + - websocket: Replace gorilla websocket transport with nhooyr websocket transport (#1982) ([libp2p/go-libp2p#1982](https://github.com/libp2p/go-libp2p/pull/1982)) + - rcmgr: Use prometheus SDK for rcmgr metrics (#2044) ([libp2p/go-libp2p#2044](https://github.com/libp2p/go-libp2p/pull/2044)) + - autorelay: Split libp2p.EnableAutoRelay into 2 functions (#2022) ([libp2p/go-libp2p#2022](https://github.com/libp2p/go-libp2p/pull/2022)) + - set names for eventbus event subscriptions (#2057) ([libp2p/go-libp2p#2057](https://github.com/libp2p/go-libp2p/pull/2057)) + - Test cleanup (#2053) ([libp2p/go-libp2p#2053](https://github.com/libp2p/go-libp2p/pull/2053)) + - metrics: use a single slice pool for all metrics tracer (#2054) ([libp2p/go-libp2p#2054](https://github.com/libp2p/go-libp2p/pull/2054)) + - eventbus: add metrics (#2038) ([libp2p/go-libp2p#2038](https://github.com/libp2p/go-libp2p/pull/2038)) + - quic: disable sending of Version Negotiation packets (#2015) ([libp2p/go-libp2p#2015](https://github.com/libp2p/go-libp2p/pull/2015)) + - p2p/test: fix flaky notification test (#2051) ([libp2p/go-libp2p#2051](https://github.com/libp2p/go-libp2p/pull/2051)) + - quic, tcp: only register Prometheus counters when metrics are enabled ([libp2p/go-libp2p#1971](https://github.com/libp2p/go-libp2p/pull/1971)) + - p2p/test: add test for EvtLocalAddressesUpdated event (#2016) ([libp2p/go-libp2p#2016](https://github.com/libp2p/go-libp2p/pull/2016)) + - quic / webtransport: extend test to test dialing draft-29 and v1 (#1957) ([libp2p/go-libp2p#1957](https://github.com/libp2p/go-libp2p/pull/1957)) + - holepunch: fix flaky by not remove holepunch protocol handler (#1948) ([libp2p/go-libp2p#1948](https://github.com/libp2p/go-libp2p/pull/1948)) + - use quic-go and webtransport-go from quic-go organization (#2040) ([libp2p/go-libp2p#2040](https://github.com/libp2p/go-libp2p/pull/2040)) + - Migrate to test-plan composite action (#2039) ([libp2p/go-libp2p#2039](https://github.com/libp2p/go-libp2p/pull/2039)) + - chore: remove license files from the eventbus package (#2042) ([libp2p/go-libp2p#2042](https://github.com/libp2p/go-libp2p/pull/2042)) + - rcmgr: *: Always close connscope (#2037) ([libp2p/go-libp2p#2037](https://github.com/libp2p/go-libp2p/pull/2037)) + - chore: remove textual roadmap in favor for Starmap (#2036) ([libp2p/go-libp2p#2036](https://github.com/libp2p/go-libp2p/pull/2036)) + - swarm metrics: fix datasource for dashboard (#2024) ([libp2p/go-libp2p#2024](https://github.com/libp2p/go-libp2p/pull/2024)) + - consistently use protocol.ID instead of strings (#2004) ([libp2p/go-libp2p#2004](https://github.com/libp2p/go-libp2p/pull/2004)) + - swarm: add a basic metrics tracer (#1973) ([libp2p/go-libp2p#1973](https://github.com/libp2p/go-libp2p/pull/1973)) + - Expose muxer ids (#2012) ([libp2p/go-libp2p#2012](https://github.com/libp2p/go-libp2p/pull/2012)) + - Clean addresses with peer id before adding to addrbook (#2007) ([libp2p/go-libp2p#2007](https://github.com/libp2p/go-libp2p/pull/2007)) + - feat: ci test-plans: Parse test timeout parameter for interop test (#2014) ([libp2p/go-libp2p#2014](https://github.com/libp2p/go-libp2p/pull/2014)) + - Export resource manager errors (#2008) ([libp2p/go-libp2p#2008](https://github.com/libp2p/go-libp2p/pull/2008)) + - peerstore: make it possible to use an empty peer ID (#2006) ([libp2p/go-libp2p#2006](https://github.com/libp2p/go-libp2p/pull/2006)) + - Add ci flakiness score to readme (#2002) ([libp2p/go-libp2p#2002](https://github.com/libp2p/go-libp2p/pull/2002)) + - rcmgr: fix: Ignore zero values when marshalling Limits. (#1998) ([libp2p/go-libp2p#1998](https://github.com/libp2p/go-libp2p/pull/1998)) + - CI: Fast multidimensional Interop tests (#1991) ([libp2p/go-libp2p#1991](https://github.com/libp2p/go-libp2p/pull/1991)) + - feat: add some users to the readme (#1981) ([libp2p/go-libp2p#1981](https://github.com/libp2p/go-libp2p/pull/1981)) + - ci: run go generate as part of the go-check workflow (#1986) ([libp2p/go-libp2p#1986](https://github.com/libp2p/go-libp2p/pull/1986)) + - switch to Google's Protobuf library, make protobufs compile with go generate ([libp2p/go-libp2p#1979](https://github.com/libp2p/go-libp2p/pull/1979)) + - circuitv2: correctly set the transport in the ConnectionState (#1972) ([libp2p/go-libp2p#1972](https://github.com/libp2p/go-libp2p/pull/1972)) + - roadmap: remove optimizations of the TCP-based handshake (#1959) ([libp2p/go-libp2p#1959](https://github.com/libp2p/go-libp2p/pull/1959)) + - identify: remove support for Identify Delta ([libp2p/go-libp2p#1975](https://github.com/libp2p/go-libp2p/pull/1975)) + - core: remove introspection package (#1978) ([libp2p/go-libp2p#1978](https://github.com/libp2p/go-libp2p/pull/1978)) + - identify: remove old code targeting Go 1.17 (#1964) ([libp2p/go-libp2p#1964](https://github.com/libp2p/go-libp2p/pull/1964)) + - add WebTransport to the list of default transports (#1915) ([libp2p/go-libp2p#1915](https://github.com/libp2p/go-libp2p/pull/1915)) + - core/crypto: drop all OpenSSL code paths (#1953) ([libp2p/go-libp2p#1953](https://github.com/libp2p/go-libp2p/pull/1953)) + - chore: use generic LRU cache (#1980) ([libp2p/go-libp2p#1980](https://github.com/libp2p/go-libp2p/pull/1980)) +- github.com/libp2p/go-libp2p-kad-dht (v0.20.0 -> v0.21.1): + - chore: bump to v0.21.1 (#821) ([libp2p/go-libp2p-kad-dht#821](https://github.com/libp2p/go-libp2p-kad-dht/pull/821)) + - feat: send FIND_NODE request to peers on routing table refresh (#810) ([libp2p/go-libp2p-kad-dht#810](https://github.com/libp2p/go-libp2p-kad-dht/pull/810)) + - chore: release v0.21. + - chore: Update to go libp2p v0.25 ([libp2p/go-libp2p-kad-dht#815](https://github.com/libp2p/go-libp2p-kad-dht/pull/815)) +- github.com/libp2p/go-libp2p-pubsub (v0.8.3 -> v0.9.0): + - chore: update to go-libp2p v0.25 (#517) ([libp2p/go-libp2p-pubsub#517](https://github.com/libp2p/go-libp2p-pubsub/pull/517)) +- github.com/libp2p/go-libp2p-routing-helpers (v0.6.0 -> v0.6.1): + - chore: release v0.6.1 + - fix: cancel parallel routers +- github.com/libp2p/go-msgio (v0.2.0 -> v0.3.0): + - release v0.3.0 (#39) ([libp2p/go-msgio#39](https://github.com/libp2p/go-msgio/pull/39)) + - switch from deprecated gogo to google.golang.org/protobuf ([libp2p/go-msgio#38](https://github.com/libp2p/go-msgio/pull/38)) + - sync: update CI config files (#36) ([libp2p/go-msgio#36](https://github.com/libp2p/go-msgio/pull/36)) +- github.com/lucas-clemente/quic-go (v0.31.1 -> v0.29.1): + - http3: fix double close of chan when using DontCloseRequestStream +- github.com/multiformats/go-multistream (v0.3.3 -> v0.4.1): + - release v0.4.1 ([multiformats/go-multistream#101](https://github.com/multiformats/go-multistream/pull/101)) + - Fix errors Is checking ([multiformats/go-multistream#100](https://github.com/multiformats/go-multistream/pull/100)) + - release v0.4.0 (#93) ([multiformats/go-multistream#93](https://github.com/multiformats/go-multistream/pull/93)) + - switch to Go's native fuzzing (#96) ([multiformats/go-multistream#96](https://github.com/multiformats/go-multistream/pull/96)) + - Add not supported protocols to returned errors (#97) ([multiformats/go-multistream#97](https://github.com/multiformats/go-multistream/pull/97)) + - Make MultistreamMuxer and Client APIs generic (#95) ([multiformats/go-multistream#95](https://github.com/multiformats/go-multistream/pull/95)) + - remove MultistreamMuxer.NegotiateLazy (#92) ([multiformats/go-multistream#92](https://github.com/multiformats/go-multistream/pull/92)) + - sync: update CI config files (#91) ([multiformats/go-multistream#91](https://github.com/multiformats/go-multistream/pull/91)) +- github.com/warpfork/go-wish (v0.0.0-20200122115046-b9ea61034e4a -> v0.0.0-20220906213052-39a1cc7a02d0): + - Update readme with deprecation info +- github.com/whyrusleeping/cbor-gen (v0.0.0-20221220214510-0333c149dec0 -> v0.0.0-20230126041949-52956bd4c9aa): + - add setter to allow reuse of cborreader struct + - fix typo + - allow fields to be ignored ([whyrusleeping/cbor-gen#79](https://github.com/whyrusleeping/cbor-gen/pull/79)) + +
+ ### 👨‍👩‍👧‍👦 Contributors + +| Contributor | Commits | Lines ± | Files Changed | +|-------------|---------|---------|---------------| +| Dirk McCormick | 128 | +16757/-7211 | 387 | +| Henrique Dias | 69 | +7599/-10016 | 316 | +| hannahhoward | 88 | +8503/-4397 | 271 | +| Jeromy Johnson | 244 | +6544/-4034 | 774 | +| Marten Seemann | 64 | +4870/-5628 | 266 | +| Steven Allen | 296 | +4769/-3517 | 972 | +| Brian Tiger Chow | 250 | +5520/-2579 | 435 | +| Jorropo | 64 | +4237/-3548 | 302 | +| Sukun | 18 | +4327/-1093 | 132 | +| Marco Munizaga | 35 | +2809/-1294 | 94 | +| Gus Eggert | 20 | +2523/-1476 | 99 | +| Adin Schmahmann | 15 | +683/-2625 | 69 | +| Marcin Rataj | 73 | +2348/-882 | 133 | +| whyrusleeping | 12 | +1683/-1338 | 23 | +| Jeromy | 99 | +1754/-1181 | 453 | +| Juan Batiz-Benet | 69 | +1182/-678 | 149 | +| Lars Gierth | 31 | +827/-358 | 92 | +| Paul Wolneykien | 2 | +670/-338 | 9 | +| Laurent Senta | 16 | +806/-134 | 53 | +| Henry | 19 | +438/-372 | 36 | +| Michael Muré | 8 | +400/-387 | 19 | +| Łukasz Magiera | 56 | +413/-354 | 117 | +| Jakub Sztandera | 40 | +413/-251 | 100 | +| Justin Johnson | 2 | +479/-165 | 5 | +| Piotr Galar | 7 | +227/-378 | 24 | +| Kevin Atkinson | 11 | +252/-232 | 49 | +| web3-bot | 17 | +236/-240 | 59 | +| Petar Maymounkov | 2 | +348/-84 | 11 | +| Hector Sanjuan | 38 | +206/-223 | 85 | +| Antonio Navarro Perez | 9 | +259/-95 | 17 | +| keks | 22 | +233/-118 | 24 | +| Ho-Sheng Hsiao | 3 | +170/-170 | 30 | +| Lucas Molas | 6 | +266/-54 | 16 | +| Mildred Ki'Lya | 4 | +280/-35 | 7 | +| Steve Loeppky | 5 | +147/-156 | 9 | +| rht | 14 | +97/-188 | 20 | +| Prithvi Shahi | 6 | +89/-193 | 11 | +| Ian Davis | 6 | +198/-75 | 11 | +| taylor | 1 | +180/-89 | 8 | +| ᴍᴀᴛᴛ ʙᴇʟʟ | 14 | +158/-104 | 18 | +| Chris Boddy | 6 | +190/-45 | 8 | +| Rod Vagg | 3 | +203/-28 | 15 | +| Masih H. Derkani | 8 | +165/-61 | 16 | +| Kevin Wallace | 4 | +194/-27 | 7 | +| Mohsin Zaidi | 1 | +179/-41 | 5 | +| ElPaisano | 1 | +110/-110 | 22 | +| Simon Zhu | 6 | +177/-32 | 8 | +| galargh | 9 | +80/-120 | 14 | +| Tomasz Zdybał | 1 | +180/-1 | 4 | +| dgrisham | 3 | +176/-2 | 4 | +| Michael Avila | 3 | +116/-59 | 8 | +| Raúl Kripalani | 2 | +85/-77 | 34 | +| Dr Ian Preston | 11 | +101/-48 | 11 | +| JP Hastings-Spital | 1 | +145/-0 | 2 | +| George Antoniadis | 6 | +59/-58 | 43 | +| Kevin Neaton | 2 | +97/-16 | 4 | +| Adrian Lanzafame | 6 | +81/-25 | 7 | +| Dennis Trautwein | 3 | +89/-9 | 5 | +| mathew-cf | 2 | +82/-9 | 5 | +| tg | 1 | +41/-33 | 1 | +| Eng Zer Jun | 1 | +15/-54 | 5 | +| zramsay | 4 | +15/-53 | 12 | +| muXxer | 1 | +28/-33 | 4 | +| Thomas Eizinger | 1 | +24/-37 | 4 | +| Remco Bloemen | 2 | +28/-18 | 3 | +| Manuel Alonso | 1 | +36/-9 | 1 | +| vyzo | 4 | +26/-12 | 13 | +| Djalil Dreamski | 3 | +27/-9 | 3 | +| Thomas Gardner | 2 | +32/-3 | 4 | +| Jan Winkelmann | 2 | +23/-12 | 8 | +| Artem Andreenko | 1 | +16/-19 | 1 | +| James Stanley | 1 | +34/-0 | 1 | +| Brendan McMillion | 1 | +10/-17 | 3 | +| Jack Loughran | 1 | +22/-0 | 3 | +| Peter Wu | 2 | +12/-9 | 2 | +| Gowtham G | 4 | +14/-7 | 4 | +| Tor Arne Vestbø | 3 | +19/-1 | 3 | +| Cory Schwartz | 1 | +8/-12 | 5 | +| Peter Rabbitson | 1 | +15/-4 | 1 | +| David Dias | 1 | +9/-9 | 1 | +| Will Scott | 1 | +13/-4 | 2 | +| Eric Myhre | 1 | +15/-2 | 1 | +| Stephen Whitmore | 1 | +8/-8 | 1 | +| Rafael Ramalho | 5 | +11/-5 | 5 | +| Christian Couder | 1 | +14/-2 | 1 | +| W. Trevor King | 2 | +9/-6 | 3 | +| Steven Vandevelde | 1 | +11/-3 | 1 | +| Knut Ahlers | 3 | +9/-5 | 3 | +| Bob Potter | 1 | +3/-10 | 1 | +| Russell Dempsey | 4 | +8/-4 | 4 | +| Diogo Silva | 4 | +8/-4 | 4 | +| Dave Justice | 1 | +8/-4 | 1 | +| Andy Leap | 2 | +2/-10 | 2 | +| divingpetrel | 1 | +7/-4 | 2 | +| Iaroslav Gridin | 1 | +9/-2 | 1 | +| Dominic Della Valle | 3 | +5/-5 | 3 | +| Vijayee Kulkaa | 1 | +3/-6 | 1 | +| Friedel Ziegelmayer | 3 | +6/-3 | 3 | +| Stephen Solka | 1 | +1/-7 | 1 | +| Richard Littauer | 3 | +4/-4 | 3 | +| Franky W | 2 | +4/-4 | 2 | +| Dimitris Apostolou | 2 | +4/-4 | 3 | +| Adrian Ulrich | 1 | +8/-0 | 1 | +| Masashi Salvador Mitsuzawa | 1 | +5/-1 | 1 | +| Gabe | 1 | +3/-3 | 1 | +| zuuluuz | 1 | +4/-1 | 1 | +| myml | 1 | +5/-0 | 1 | +| swedneck | 1 | +3/-1 | 1 | +| Wayback Archiver | 1 | +2/-2 | 1 | +| Vladimir Ivanov | 1 | +2/-2 | 1 | +| Péter Szilágyi | 1 | +2/-2 | 1 | +| Karthik Bala | 1 | +2/-2 | 1 | +| Etienne Laurin | 1 | +1/-3 | 1 | +| Shotaro Yamada | 1 | +2/-1 | 1 | +| Robert Carlsen | 1 | +2/-1 | 1 | +| Oli Evans | 1 | +2/-1 | 1 | +| Dan McQuillan | 1 | +2/-1 | 1 | +| susarlanikhilesh | 1 | +1/-1 | 1 | +| mateon1 | 1 | +1/-1 | 1 | +| kpcyrd | 1 | +1/-1 | 1 | +| bbenshoof | 1 | +1/-1 | 1 | +| ZenGround0 | 1 | +1/-1 | 1 | +| Will Hawkins | 1 | +1/-1 | 1 | +| Tommi Virtanen | 1 | +1/-1 | 1 | +| Seungbae Yu | 1 | +1/-1 | 1 | +| Riishab Joshi | 1 | +1/-1 | 1 | +| Kubo Mage | 1 | +1/-1 | 1 | +| Ivan | 1 | +1/-1 | 1 | +| Guillaume Renault | 1 | +1/-1 | 1 | +| Anjor Kanekar | 1 | +1/-1 | 1 | +| Andrew Chin | 1 | +1/-1 | 1 | +| Abdul Rauf | 1 | +1/-1 | 1 | +| makeworld | 1 | +1/-0 | 1 | From b975593920455c32793d4d233e49ee6762fbaf3b Mon Sep 17 00:00:00 2001 From: Henrique Dias Date: Mon, 20 Mar 2023 14:14:38 +0100 Subject: [PATCH 91/93] feat(gateway): invalid CID returns 400 Bad Request (#9726) --- docs/examples/kubo-as-a-library/go.mod | 4 ++-- docs/examples/kubo-as-a-library/go.sum | 8 ++++---- go.mod | 4 ++-- go.sum | 8 ++++---- test/cli/gateway_test.go | 8 ++++---- test/sharness/t0090-get.sh | 2 +- 6 files changed, 17 insertions(+), 17 deletions(-) diff --git a/docs/examples/kubo-as-a-library/go.mod b/docs/examples/kubo-as-a-library/go.mod index 5453ae1d581..cb8e9bc9a3e 100644 --- a/docs/examples/kubo-as-a-library/go.mod +++ b/docs/examples/kubo-as-a-library/go.mod @@ -7,7 +7,7 @@ go 1.18 replace github.com/ipfs/kubo => ./../../.. require ( - github.com/ipfs/go-libipfs v0.6.2 + github.com/ipfs/go-libipfs v0.7.0 github.com/ipfs/interface-go-ipfs-core v0.11.0 github.com/ipfs/kubo v0.0.0-00010101000000-000000000000 github.com/libp2p/go-libp2p v0.26.3 @@ -65,7 +65,7 @@ require ( github.com/ipfs/go-bitfield v1.1.0 // indirect github.com/ipfs/go-block-format v0.1.1 // indirect github.com/ipfs/go-blockservice v0.5.0 // indirect - github.com/ipfs/go-cid v0.3.2 // indirect + github.com/ipfs/go-cid v0.4.0 // indirect github.com/ipfs/go-cidutil v0.1.0 // indirect github.com/ipfs/go-datastore v0.6.0 // indirect github.com/ipfs/go-delegated-routing v0.7.0 // indirect diff --git a/docs/examples/kubo-as-a-library/go.sum b/docs/examples/kubo-as-a-library/go.sum index 6f7e7f253b3..bfdbf90fe47 100644 --- a/docs/examples/kubo-as-a-library/go.sum +++ b/docs/examples/kubo-as-a-library/go.sum @@ -460,8 +460,8 @@ github.com/ipfs/go-cid v0.0.5/go.mod h1:plgt+Y5MnOey4vO4UlUazGqdbEXuFYitED67Fexh github.com/ipfs/go-cid v0.0.6/go.mod h1:6Ux9z5e+HpkQdckYoX1PG/6xqKspzlEIR5SDmgqgC/I= github.com/ipfs/go-cid v0.0.7/go.mod h1:6Ux9z5e+HpkQdckYoX1PG/6xqKspzlEIR5SDmgqgC/I= github.com/ipfs/go-cid v0.1.0/go.mod h1:rH5/Xv83Rfy8Rw6xG+id3DYAMUVmem1MowoKwdXmN2o= -github.com/ipfs/go-cid v0.3.2 h1:OGgOd+JCFM+y1DjWPmVH+2/4POtpDzwcr7VgnB7mZXc= -github.com/ipfs/go-cid v0.3.2/go.mod h1:gQ8pKqT/sUxGY+tIwy1RPpAojYu7jAyCp5Tz1svoupw= +github.com/ipfs/go-cid v0.4.0 h1:a4pdZq0sx6ZSxbCizebnKiMCx/xI/aBBFlB73IgH4rA= +github.com/ipfs/go-cid v0.4.0/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk= github.com/ipfs/go-cidutil v0.1.0 h1:RW5hO7Vcf16dplUU60Hs0AKDkQAVPVplr7lk97CFL+Q= github.com/ipfs/go-cidutil v0.1.0/go.mod h1:e7OEVBMIv9JaOxt9zaGEmAoSlXW9jdFZ5lP/0PwcfpA= github.com/ipfs/go-datastore v0.0.1/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE= @@ -569,8 +569,8 @@ github.com/ipfs/go-ipld-legacy v0.1.1 h1:BvD8PEuqwBHLTKqlGFTHSwrwFOMkVESEvwIYwR2 github.com/ipfs/go-ipld-legacy v0.1.1/go.mod h1:8AyKFCjgRPsQFf15ZQgDB8Din4DML/fOmKZkkFkrIEg= github.com/ipfs/go-ipns v0.3.0 h1:ai791nTgVo+zTuq2bLvEGmWP1M0A6kGTXUsgv/Yq67A= github.com/ipfs/go-ipns v0.3.0/go.mod h1:3cLT2rbvgPZGkHJoPO1YMJeh6LtkxopCkKFcio/wE24= -github.com/ipfs/go-libipfs v0.6.2 h1:QUf3kS3RrCjgtE0QW2d18PFFfOLeEt24Ft892ipLzRI= -github.com/ipfs/go-libipfs v0.6.2/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= +github.com/ipfs/go-libipfs v0.7.0 h1:Mi54WJTODaOL2/ZSm5loi3SwI3jI2OuFWUrQIkJ5cpM= +github.com/ipfs/go-libipfs v0.7.0/go.mod h1:KsIf/03CqhICzyRGyGo68tooiBE2iFbI/rXW7FhAYr0= github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk= github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A= diff --git a/go.mod b/go.mod index f7237b46a74..4a8bf632c58 100644 --- a/go.mod +++ b/go.mod @@ -17,7 +17,7 @@ require ( github.com/google/uuid v1.3.0 github.com/hashicorp/go-multierror v1.1.1 github.com/ipfs/go-blockservice v0.5.0 - github.com/ipfs/go-cid v0.3.2 + github.com/ipfs/go-cid v0.4.0 github.com/ipfs/go-cidutil v0.1.0 github.com/ipfs/go-datastore v0.6.0 github.com/ipfs/go-delegated-routing v0.7.0 @@ -45,7 +45,7 @@ require ( github.com/ipfs/go-ipld-git v0.1.1 github.com/ipfs/go-ipld-legacy v0.1.1 github.com/ipfs/go-ipns v0.3.0 - github.com/ipfs/go-libipfs v0.6.2 + github.com/ipfs/go-libipfs v0.7.0 github.com/ipfs/go-log v1.0.5 github.com/ipfs/go-log/v2 v2.5.1 github.com/ipfs/go-merkledag v0.9.0 diff --git a/go.sum b/go.sum index 27e101e1c8a..c259bc1a127 100644 --- a/go.sum +++ b/go.sum @@ -478,8 +478,8 @@ github.com/ipfs/go-cid v0.0.5/go.mod h1:plgt+Y5MnOey4vO4UlUazGqdbEXuFYitED67Fexh github.com/ipfs/go-cid v0.0.6/go.mod h1:6Ux9z5e+HpkQdckYoX1PG/6xqKspzlEIR5SDmgqgC/I= github.com/ipfs/go-cid v0.0.7/go.mod h1:6Ux9z5e+HpkQdckYoX1PG/6xqKspzlEIR5SDmgqgC/I= github.com/ipfs/go-cid v0.1.0/go.mod h1:rH5/Xv83Rfy8Rw6xG+id3DYAMUVmem1MowoKwdXmN2o= -github.com/ipfs/go-cid v0.3.2 h1:OGgOd+JCFM+y1DjWPmVH+2/4POtpDzwcr7VgnB7mZXc= -github.com/ipfs/go-cid v0.3.2/go.mod h1:gQ8pKqT/sUxGY+tIwy1RPpAojYu7jAyCp5Tz1svoupw= +github.com/ipfs/go-cid v0.4.0 h1:a4pdZq0sx6ZSxbCizebnKiMCx/xI/aBBFlB73IgH4rA= +github.com/ipfs/go-cid v0.4.0/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk= github.com/ipfs/go-cidutil v0.1.0 h1:RW5hO7Vcf16dplUU60Hs0AKDkQAVPVplr7lk97CFL+Q= github.com/ipfs/go-cidutil v0.1.0/go.mod h1:e7OEVBMIv9JaOxt9zaGEmAoSlXW9jdFZ5lP/0PwcfpA= github.com/ipfs/go-datastore v0.0.1/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE= @@ -591,8 +591,8 @@ github.com/ipfs/go-ipld-legacy v0.1.1 h1:BvD8PEuqwBHLTKqlGFTHSwrwFOMkVESEvwIYwR2 github.com/ipfs/go-ipld-legacy v0.1.1/go.mod h1:8AyKFCjgRPsQFf15ZQgDB8Din4DML/fOmKZkkFkrIEg= github.com/ipfs/go-ipns v0.3.0 h1:ai791nTgVo+zTuq2bLvEGmWP1M0A6kGTXUsgv/Yq67A= github.com/ipfs/go-ipns v0.3.0/go.mod h1:3cLT2rbvgPZGkHJoPO1YMJeh6LtkxopCkKFcio/wE24= -github.com/ipfs/go-libipfs v0.6.2 h1:QUf3kS3RrCjgtE0QW2d18PFFfOLeEt24Ft892ipLzRI= -github.com/ipfs/go-libipfs v0.6.2/go.mod h1:FmhKgxMOQA572TK5DA3MZ5GL44ZqsMHIrkgK4gLn4A8= +github.com/ipfs/go-libipfs v0.7.0 h1:Mi54WJTODaOL2/ZSm5loi3SwI3jI2OuFWUrQIkJ5cpM= +github.com/ipfs/go-libipfs v0.7.0/go.mod h1:KsIf/03CqhICzyRGyGo68tooiBE2iFbI/rXW7FhAYr0= github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk= github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A= diff --git a/test/cli/gateway_test.go b/test/cli/gateway_test.go index d2a90b04ae4..4c40729c708 100644 --- a/test/cli/gateway_test.go +++ b/test/cli/gateway_test.go @@ -126,10 +126,10 @@ func TestGateway(t *testing.T) { assert.Equal(t, 404, resp.StatusCode) }) - t.Run("GET IPFS invalid CID returns 500 (Internal Server Error)", func(t *testing.T) { + t.Run("GET IPFS invalid CID returns 400 (Bad Request)", func(t *testing.T) { t.Parallel() resp := client.Get("/ipfs/QmInvalid/pleaseDontAddMe") - assert.Equal(t, 500, resp.StatusCode) + assert.Equal(t, 400, resp.StatusCode) }) t.Run("GET IPFS inlined zero-length data object returns ok code (200)", func(t *testing.T) { @@ -198,7 +198,7 @@ func TestGateway(t *testing.T) { t.Run("GET invalid IPFS path errors", func(t *testing.T) { t.Parallel() - assert.Equal(t, 500, client.Get("/ipfs/12345").StatusCode) + assert.Equal(t, 400, client.Get("/ipfs/12345").StatusCode) }) t.Run("GET invalid path errors", func(t *testing.T) { @@ -406,7 +406,7 @@ func TestGateway(t *testing.T) { gatewayAddr := URLStrToMultiaddr(node.GatewayURL()) res := node.RunIPFS("--api", gatewayAddr.String(), "refs", "local") assert.Equal(t, - `Error: invalid path "local": selected encoding not supported`, + `Error: invalid path "local": invalid cid: selected encoding not supported`, res.Stderr.Trimmed(), ) }) diff --git a/test/sharness/t0090-get.sh b/test/sharness/t0090-get.sh index 5e16c7d01fe..2f3838db475 100755 --- a/test/sharness/t0090-get.sh +++ b/test/sharness/t0090-get.sh @@ -129,7 +129,7 @@ test_get_cmd() { ' test_expect_success "ipfs get ../.. should fail" ' - echo "Error: invalid path \"../..\": selected encoding not supported" >expected && + echo "Error: invalid path \"../..\": invalid cid: selected encoding not supported" >expected && test_must_fail ipfs get ../.. 2>actual && test_cmp expected actual ' From 1f36e3dbe6f9ca6335182150626e4c15fcb8aa8b Mon Sep 17 00:00:00 2001 From: galargh Date: Mon, 20 Mar 2023 16:35:00 +0000 Subject: [PATCH 92/93] chore: create next changelog --- CHANGELOG.md | 1 + docs/changelogs/v0.20.md | 18 ++++++++++++++++++ 2 files changed, 19 insertions(+) create mode 100644 docs/changelogs/v0.20.md diff --git a/CHANGELOG.md b/CHANGELOG.md index 16e72bcb150..2659f260841 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,6 @@ # Kubo Changelogs +- [v0.20](docs/changelogs/v0.20.md) - [v0.19](docs/changelogs/v0.19.md) - [v0.18](docs/changelogs/v0.18.md) - [v0.17](docs/changelogs/v0.17.md) diff --git a/docs/changelogs/v0.20.md b/docs/changelogs/v0.20.md new file mode 100644 index 00000000000..c1c3e9639d0 --- /dev/null +++ b/docs/changelogs/v0.20.md @@ -0,0 +1,18 @@ +# Kubo changelog v0.20 + +- [v0.20.0](#v0200) + +## v0.20.0 + +- [Overview](#overview) +- [🔦 Highlights](#-highlights) +- [📝 Changelog](#-changelog) +- [👨‍👩‍👧‍👦 Contributors](#-contributors) + +### Overview + +### 🔦 Highlights + +### 📝 Changelog + +### 👨‍👩‍👧‍👦 Contributors From e0b08ed7832d8275477ebf7e493824e87fca73ce Mon Sep 17 00:00:00 2001 From: Gus Eggert Date: Mon, 20 Mar 2023 17:27:45 -0400 Subject: [PATCH 93/93] docs: use fx.Decorate instead of fx.Replace in examples (#9725) In practice there are cases when fx.Replace doesn't work as expected, so this updates the documentation to recommend using fx.Decorate instead which is a bit easier to use. --- docs/plugins.md | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/docs/plugins.md b/docs/plugins.md index 1feca834c0c..86cfe1c51f4 100644 --- a/docs/plugins.md +++ b/docs/plugins.md @@ -51,14 +51,15 @@ plugin type is likely the best interim solution. ### fx (experimental) Fx plugins let you customize the [fx](https://pkg.go.dev/go.uber.org/fx) dependency graph and configuration, -by customizing the`fx.Option`s that are passed to `fx` when the IPFS node is initialized. +by customizing the`fx.Option`s that are passed to `fx` when the Kubo node is initialized. -For example, you can inject custom implementations of interfaces such as [exchange.Interface](https://github.com/ipfs/go-ipfs-exchange-interface) -or [pin.Pinner](https://github.com/ipfs/go-ipfs-pinner) by adding an option like `fx.Replace(fx.Annotate(customExchange, fx.As(new(exchange.Interface))))`. +For example, you can override an interface such as [exchange.Interface](https://github.com/ipfs/go-ipfs-exchange-interface) +or [pin.Pinner](https://github.com/ipfs/go-ipfs-pinner) with a custom implementation by appending an option like +`fx.Decorate(func() exchange.Interface { return customExchange })`. Fx supports some advanced customization. Simple interface replacements like above are unlikely to break in the future, but the more invasive your changes, the more likely they are to break between releases. Kubo cannot guarantee backwards -compatibility for invasive `fx` customizations. +compatibility for `fx` customizations. Fx options are applied across every execution of the `ipfs` binary, including: @@ -68,7 +69,7 @@ Fx options are applied across every execution of the `ipfs` binary, including: - etc. So if you plug in a blockservice that disallows non-allowlisted CIDs, then this may break migrations -that fetch migration code over IPFS. +that fetch migration code over the IPFS network. ### Internal

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 literal 0 HcmV?d00001 From 5b9442cfed8b668c1f2c9f968c1a4c86c82af201 Mon Sep 17 00:00:00 2001 From: Henrique Dias Date: Tue, 14 Mar 2023 13:53:17 +0100 Subject: [PATCH 54/93] Revert "chore: add hamt directory sharding test" This reverts commit d23702bbf8513094ca445bea52742d952e80a8dc. --- test/sharness/t0115-gateway-dir-listing.sh | 24 ++---------------- .../t0115-gateway-dir-listing/README.md | 23 +---------------- .../t0115-gateway-dir-listing/hamt-refs.car | Bin 782149 -> 0 bytes 3 files changed, 3 insertions(+), 44 deletions(-) delete mode 100644 test/sharness/t0115-gateway-dir-listing/hamt-refs.car diff --git a/test/sharness/t0115-gateway-dir-listing.sh b/test/sharness/t0115-gateway-dir-listing.sh index 4681e63ee62..cf95bf4b05e 100755 --- a/test/sharness/t0115-gateway-dir-listing.sh +++ b/test/sharness/t0115-gateway-dir-listing.sh @@ -13,34 +13,14 @@ test_description="Test directory listing (dir-index-html) on the HTTP gateway" test_expect_success "ipfs init" ' export IPFS_PATH="$(pwd)/.ipfs" && - ipfs init --empty-repo --profile=test > /dev/null + ipfs init --profile=test > /dev/null ' test_launch_ipfs_daemon_without_network -# HAMT-sharded directory test. We must execute this test first as we want to -# start from an empty repository and count the exact number of refs we want. -HAMT_CID=bafybeiggvykl7skb2ndlmacg2k5modvudocffxjesexlod2pfvg5yhwrqm -HAMT_REFS_CID=bafybeicv4utmj46mgbpamvw2k6zg4qjs5yvspfnlxz2y6iuey5smjfcn4a -HAMT_REFS_COUNT=963 - -test_expect_success "hamt: import fixture with necessary refs" ' - ipfs dag import ../t0115-gateway-dir-listing/hamt-refs.car && - ipfs refs local | wc -l | tr -d " " > refs_count_actual && - echo $HAMT_REFS_COUNT > refs_count_expected && - test_cmp refs_count_expected refs_count_actual -' - -test_expect_success "hamt: fetch directory from gateway in offline mode" ' - curl --max-time 1 -sD - http://127.0.0.1:$GWAY_PORT/ipfs/$HAMT_CID/ > hamt_list_response && - ipfs refs local | wc -l | tr -d " " > refs_count_actual && - echo $HAMT_REFS_COUNT > refs_count_expected && - test_cmp refs_count_expected refs_count_actual -' - # Import test case # See the static fixtures in ./t0115-gateway-dir-listing/ -test_expect_success "add remaining test fixtures" ' +test_expect_success "Add the test directory" ' ipfs dag import ../t0115-gateway-dir-listing/fixtures.car ' DIR_CID=bafybeig6ka5mlwkl4subqhaiatalkcleo4jgnr3hqwvpmsqfca27cijp3i # ./rootDir/ diff --git a/test/sharness/t0115-gateway-dir-listing/README.md b/test/sharness/t0115-gateway-dir-listing/README.md index 7da44078ba3..937438bcd65 100644 --- a/test/sharness/t0115-gateway-dir-listing/README.md +++ b/test/sharness/t0115-gateway-dir-listing/README.md @@ -2,12 +2,8 @@ - fixtures.car - raw CARv1 -- hamt-refs.car - - raw CARv1 containing all the necessary blocks to present a directory listing - for `bafybeiggvykl7skb2ndlmacg2k5modvudocffxjesexlod2pfvg5yhwrqm`, which is - a directory containing over 10k items. -fixutres.car generated with: +generated with: ```sh # using ipfs version 0.18.1 @@ -34,20 +30,3 @@ ipfs dag export ${DIR_CID} > ./fixtures.car # FILE_CID=bafkreialihlqnf5uwo4byh4n3cmwlntwqzxxs2fg5vanqdi3d7tb2l5xkm # ./rootDir/ą/ę/file-źł.txt # FILE_SIZE=34 ``` - -hamt-refs.car generated with: - -```sh -# using ipfs version 0.18.1 -export IPFS_PATH=$(mktemp -d) -ipfs init --empty-repo -ipfs daemon & -curl http://127.0.0.1:8080/ipfs/bafybeiggvykl7skb2ndlmacg2k5modvudocffxjesexlod2pfvg5yhwrqm/ -killall ipfs -ipfs refs local >> refs -ipfs files mkdir --cid-version 1 /Test -cat refs | xargs -I {} ipfs files cp /ipfs/{} /Test/{} -ipfs files stat /Test -# Grab CID: bafybeicv4utmj46mgbpamvw2k6zg4qjs5yvspfnlxz2y6iuey5smjfcn4a -ipfs dag export bafybeicv4utmj46mgbpamvw2k6zg4qjs5yvspfnlxz2y6iuey5smjfcn4a > ./refs.car -``` diff --git a/test/sharness/t0115-gateway-dir-listing/hamt-refs.car b/test/sharness/t0115-gateway-dir-listing/hamt-refs.car deleted file mode 100644 index 58069310cc4eccb612a4b272050f4064e2652232..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 782149 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