diff --git a/.circleci/config.yml b/.circleci/config.yml index 93ef8a70eb9..ae52998aafd 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -33,7 +33,7 @@ default_environment: &default_environment executors: golang: docker: - - image: circleci/golang:1.13.8 + - image: circleci/golang:1.14.2 working_directory: ~/ipfs/go-ipfs environment: <<: *default_environment @@ -44,7 +44,7 @@ executors: TEST_VERBOSE: 1 node: docker: - - image: circleci/node:10 + - image: circleci/node:12 working_directory: ~/ipfs/go-ipfs environment: <<: *default_environment @@ -60,7 +60,7 @@ executors: E2E_IPFSD_TYPE: go dockerizer: docker: - - image: circleci/golang:1.13.8 + - image: circleci/golang:1.14.2 environment: IMAGE_NAME: ipfs/go-ipfs WIP_IMAGE_TAG: wip @@ -191,15 +191,14 @@ jobs: - run: name: Installing reporting tools command: | - npm install --save-dev mocha-junit-reporter@1.23.1 mocha-multi-reporters@1.1.0 + npm install --save-dev mocha-circleci-reporter@0.0.3 working_directory: ~/ipfs/go-ipfs/interop - run: name: Running tests command: | mkdir -p /tmp/test-results/interop/ export MOCHA_FILE="$(mktemp /tmp/test-results/interop/unit.XXXXXX.xml)" - echo '{"reporterEnabled": "mocha-junit-reporter, spec"}' > mocha-conf.json - node_modules/.bin/mocha -R mocha-multi-reporters --reporter-options "configFile=mocha-conf.json" \ + node_modules/.bin/mocha --reporter mocha-circleci-reporter \ $(sed -n -e "s|^require('\(.*\)')$|test/\1|p" test/node.js | circleci tests split) working_directory: ~/ipfs/go-ipfs/interop environment: diff --git a/.github/auto-comment.yml b/.github/auto-comment.yml new file mode 100644 index 00000000000..c1272240633 --- /dev/null +++ b/.github/auto-comment.yml @@ -0,0 +1,6 @@ +# Comment to a new issue. +# Disabled +# issueOpened: "" + +# Disabled +# pullRequestOpened: "" diff --git a/.github/config.yml b/.github/config.yml new file mode 100644 index 00000000000..ed26646a0f7 --- /dev/null +++ b/.github/config.yml @@ -0,0 +1,68 @@ +# Configuration for welcome - https://github.com/behaviorbot/welcome + +# Configuration for new-issue-welcome - https://github.com/behaviorbot/new-issue-welcome +# Comment to be posted to on first time issues +newIssueWelcomeComment: > + Thank you for submitting your first issue to this repository! A maintainer + will be here shortly to triage and review. + + In the meantime, please double-check that you have provided all the + necessary information to make this process easy! Any information that can + help save additional round trips is useful! We currently aim to give + initial feedback within **two business days**. If this does not happen, feel + free to leave a comment. + + Please keep an eye on how this issue will be labeled, as labels give an + overview of priorities, assignments and additional actions requested by the + maintainers: + + - "Priority" labels will show how urgent this is for the team. + - "Status" labels will show if this is ready to be worked on, blocked, or in progress. + - "Need" labels will indicate if additional input or analysis is required. + + Finally, remember to use https://discuss.ipfs.io if you just need general + support. + +# Configuration for new-pr-welcome - https://github.com/behaviorbot/new-pr-welcome +# Comment to be posted to on PRs from first time contributors in your repository +newPRWelcomeComment: > + Thank you for submitting this PR! + + A maintainer will be here shortly to review it. + + We are super grateful, but we are also overloaded! Help us by making sure + that: + + * The context for this PR is clear, with relevant discussion, decisions + and stakeholders linked/mentioned. + + * Your contribution itself is clear (code comments, self-review for the + rest) and in its best form. Follow the [code contribution + guidelines](https://github.com/ipfs/community/blob/master/CONTRIBUTING.md#code-contribution-guidelines) + if they apply. + + Getting other community members to do a review would be great help too on + complex PRs (you can ask in the chats/forums). If you are unsure about + something, just leave us a comment. + + Next steps: + + * A maintainer will triage and assign priority to this PR, commenting on + any missing things and potentially assigning a reviewer for high + priority items. + + * The PR gets reviews, discussed and approvals as needed. + + * The PR is merged by maintainers when it has been approved and comments addressed. + + We currently aim to provide initial feedback/triaging within **two business + days**. Please keep an eye on any labelling actions, as these will indicate + priorities and status of your contribution. + + We are very grateful for your contribution! + + +# Configuration for first-pr-merge - https://github.com/behaviorbot/first-pr-merge +# Comment to be posted to on pull requests merged by a first time user +# Currently disabled +#firstPRMergeComment: "" diff --git a/CHANGELOG.md b/CHANGELOG.md index d4b73978ee7..e803b2a2b1e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,407 @@ # go-ipfs changelog +## v0.6.0 2020-06-19 + +This is a relatively small release in terms of code changes, but it contains some significant changes to the IPFS protocol. + +### Highlights + +The highlights in this release include: + +* The QUIC transport is enabled by default. Furthermore, go-ipfs will automatically run a migration to listen on the QUIC transport (on the same address/port as the TCP transport) to make this upgrade process seamless. +* The new NOISE security transport is now supported but won't be selected by default. This transport will replace SECIO as the default cross-language interoperability security transport. TLS 1.3 will still remain the default security transport between go-ipfs nodes for now. + +**MIGRATION:** This release contains a small config migration to enable listening on the QUIC transport in addition the TCP transport. This migration will: + +* Normalize multiaddrs in the bootstrap list to use the `/p2p/Qm...` syntax for multiaddrs instead of the `/ipfs/Qm...` syntax. +* Add QUIC addresses for the default bootstrapers, as necessary. If you've removed the default bootstrappers from your bootstrap config, the migration won't add them back. +* Add a QUIC listener address to mirror any TCP addresses present in your config. For example, if you're listening on `/ip4/0.0.0.0/tcp/1234`, this migration will add a listen address for `/ip4/0.0.0.0/udp/1234/quic`. + +#### QUIC by default + +This release enables the QUIC transport (draft 28) by default for both inbound and outbound connections. When connecting to new peers, libp2p will continue to dial all advertised addresses (tcp + quic) in parallel so if the QUIC connection fails for some reason, the connection should still succeed. + +The QUIC transport has several key benefits over the current TCP based transports: + +* It takes fewer round-trips to establish a connection. With the QUIC transport, the IPFS handshake takes two round trips (one to establish the QUIC connection, one for the libp2p handshake). In the future, we should be able to reduce this to one round trip for the initial connection, and zero round trips for subsequent connections to a previously seen peer. This is especially important for DHT requests that contact many new peers. +* Because it's UDP based instead of TCP based, it uses fewer file descriptors. The QUIC transport will open one UDP socket per listen address instead of one socket per connection. This should, in the future, allow us to keep more connections open. +* Because QUIC connections don't consume file descriptors, we're able to remove the rate limit on outbound QUIC connections, further speeding up DHT queries. + +Unfortunately, this change isn't without drawbacks: the QUIC transport may not be able to max out some links (usually due to [poorly tuned kernel parameters](https://github.com/lucas-clemente/quic-go/issues/2586#issuecomment-639247615)). On the other hand, it may also be _faster_ in some cases + +If you hit this performance issue on Linux, you should tune the `net.core.rmem_default` and `net.core.rmem_max` sysctl parameters to increase your UDP receive buffer sizes. + +If necessary, you can disable the QUIC transport by running: + +```bash +> ipfs config --json Swarm.Transports.Network.QUIC false +``` + +**NOTE:** The QUIC transport included in this release is backwards incompatible with the experimental QUIC transport included in previous releases. Unfortunately, the QUIC protocol underwent some significant breaking changes and supporting multiple versions wasn't an option. In practice this degrades gracefully as go-ipfs will simply fall back on the TCP transport when dialing nodes with incompatible QUIC versions. + +#### Noise Transport + +This go-ipfs release introduces a new security transport: [libp2p Noise](https://github.com/libp2p/specs/tree/master/noise) (built from the [Noise Protocol Framework](http://www.noiseprotocol.org/)). While TLS1.3 remains the default go-ipfs security transport, Noise is simpler to implement from scratch and will be the standard cross-platform libp2p security transport going forward. + +This brings us one step closer to deprecating and removing support for SECIO. + +While enabled by default, Noise won't actually be _used_ by default it's negotiated. Given that TLS1.3 is still the default security transport for go-ipfs, this usually won't happen. If you'd like to prefer Noise over other security transports, you can change its priority in the [config](./docs/config.md) (`Swarm.Transports.Security.Noise`). + +#### Gateway + +This release brings two gateway-relevant features: custom 404 pages and base36 support. + +##### Custom 404 + +You can now customize `404 Not Found` error pages by including an `ipfs-404.html` file somewhere in the request path. When a requested file isn't found, go-ipfs will look for an `ipfs-404.html` in the same directory as the requested file, and in each ancestor directory. If found, this file will be returned (with a 404 status code) instead of the usual error message. + +##### Support for Base36 + +This release adds support for a new multibase encoding: base36. Base36 is an optimally efficient case-insensitive alphanumeric encoding. Case-insensitive alphanumeric encodings are important for the subdomain gateway as domain names are case insensitive. + +While base32 (the current default encoding used in subdomains) is simpler than base36, it's not optimally efficient and base36 Ed25519 IPNS keys are 2 characters too big to fit into the 63 character subdomain length limit. The extra efficiency from base36 brings us under this limit and allows Ed25519 IPNS keys to work with the subdomain gateway. + +This release adds support for base36 but won't use it by default. If you'd like to re-encode an Ed25519 IPNS key into base36, you can use the `ipfs cid format` command: + +```sh +$ ipfs cid format -v 1 --codec libp2p-key -b base36 bafzaajaiaejca4syrpdu6gdx4wsdnokxkprgzxf4wrstuc34gxw5k5jrag2so5gk k51qzi5uqu5dj16qyiq0tajolkojyl9qdkr254920wxv7ghtuwcz593tp69z9m +``` + +#### Gossipsub Upgrade + +This release brings a new gossipsub protocol version: 1.1. You can read about it in the [blog post](https://blog.ipfs.io/2020-05-20-gossipsub-v1.1/). + +#### Connectivity + +This release introduces a new ["peering"](./docs/config.md#peering) feature. The peering subsystem configures go-ipfs to connect to, remain connected to, and reconnect to a set of nodes. Nodes should use this subsystem to create "sticky" links between frequently useful peers to improve reliability. + +Use-cases: + +* An IPFS gateway connected to an IPFS cluster should peer to ensure that the gateway can always fetch content from the cluster. +* A dapp may peer embedded go-ipfs nodes with a set of pinning services or textile cafes/hubs. +* A set of friends may peer to ensure that they can always fetch each other's content. + +### Changelog + +- github.com/ipfs/go-ipfs: + - fix 3 bugs responsible for a goroutine leak (plus one other bug) ([ipfs/go-ipfs#7491](https://github.com/ipfs/go-ipfs/pull/7491)) + - docs(config): update toc ([ipfs/go-ipfs#7483](https://github.com/ipfs/go-ipfs/pull/7483)) + - feat: transport config ([ipfs/go-ipfs#7479](https://github.com/ipfs/go-ipfs/pull/7479)) + - fix the minimal go version under 'Build from Source' ([ipfs/go-ipfs#7459](https://github.com/ipfs/go-ipfs/pull/7459)) + - fix(migration): migrate /ipfs/ bootstrappers to /p2p/ + - fix(migration): correctly migrate quic addresses + - chore: add migration to listen on QUIC by default + - backport fixes ([ipfs/go-ipfs#7405](https://github.com/ipfs/go-ipfs/pull/7405)) + - Use bitswap sessions for `ipfs refs`. + - Update to webui 2.9.0 + - feat: add noise support ([ipfs/go-ipfs#7365](https://github.com/ipfs/go-ipfs/pull/7365)) + - feat: implement peering service ([ipfs/go-ipfs#7362](https://github.com/ipfs/go-ipfs/pull/7362)) + - Include the git blob id of the dir-index bundle in the ETag ([ipfs/go-ipfs#7360](https://github.com/ipfs/go-ipfs/pull/7360)) + - feat: bootstrap in dht when the routing table is empty ([ipfs/go-ipfs#7340](https://github.com/ipfs/go-ipfs/pull/7340)) + - quic: remove experimental status and add it to the default config ([ipfs/go-ipfs#7349](https://github.com/ipfs/go-ipfs/pull/7349)) + - fix: support directory listings even if a 404 page is present ([ipfs/go-ipfs#7339](https://github.com/ipfs/go-ipfs/pull/7339)) + - doc(plugin): document plugin config ([ipfs/go-ipfs#7309](https://github.com/ipfs/go-ipfs/pull/7309)) + - test(sharness): fix fuse tests ([ipfs/go-ipfs#7320](https://github.com/ipfs/go-ipfs/pull/7320)) + - docs: update experimental-features doc with IPNS over pubsub changes. ([ipfs/go-ipfs#7334](https://github.com/ipfs/go-ipfs/pull/7334)) + - docs: cleanup config formatting ([ipfs/go-ipfs#7336](https://github.com/ipfs/go-ipfs/pull/7336)) + - fix(gateway): ensure directory listings have Content-Type text/html ([ipfs/go-ipfs#7330](https://github.com/ipfs/go-ipfs/pull/7330)) + - test(sharness): test the local symlink ([ipfs/go-ipfs#7332](https://github.com/ipfs/go-ipfs/pull/7332)) + - misc config/experimental-features doc fixes ([ipfs/go-ipfs#7333](https://github.com/ipfs/go-ipfs/pull/7333)) + - fix: correctly trim resolved IPNS addresses ([ipfs/go-ipfs#7331](https://github.com/ipfs/go-ipfs/pull/7331)) + - Gateway renders pretty 404 pages if available ([ipfs/go-ipfs#4233](https://github.com/ipfs/go-ipfs/pull/4233)) + - feat: add a dht stat command ([ipfs/go-ipfs#7221](https://github.com/ipfs/go-ipfs/pull/7221)) + - fix: update dists url for OpenBSD support ([ipfs/go-ipfs#7311](https://github.com/ipfs/go-ipfs/pull/7311)) + - docs: X-Forwarded-Proto: https ([ipfs/go-ipfs#7306](https://github.com/ipfs/go-ipfs/pull/7306)) + - fix(mkreleaselog): make robust against running in different working directories ([ipfs/go-ipfs#7310](https://github.com/ipfs/go-ipfs/pull/7310)) + - fix(mkreleasenotes): include commits directly to master ([ipfs/go-ipfs#7296](https://github.com/ipfs/go-ipfs/pull/7296)) + - write api file automically ([ipfs/go-ipfs#7282](https://github.com/ipfs/go-ipfs/pull/7282)) + - systemd: disable swap-usage for ipfs ([ipfs/go-ipfs#7299](https://github.com/ipfs/go-ipfs/pull/7299)) + - systemd: add helptext ([ipfs/go-ipfs#7265](https://github.com/ipfs/go-ipfs/pull/7265)) + - systemd: add the link to the docs ([ipfs/go-ipfs#7287](https://github.com/ipfs/go-ipfs/pull/7287)) + - systemd: add state directory setting ([ipfs/go-ipfs#7288](https://github.com/ipfs/go-ipfs/pull/7288)) + - Update go version required to build ([ipfs/go-ipfs#7289](https://github.com/ipfs/go-ipfs/pull/7289)) + - pin: implement pin/ls with only CoreApi ([ipfs/go-ipfs#6774](https://github.com/ipfs/go-ipfs/pull/6774)) + - update go-libp2p-quic-transport to v0.3.7 ([ipfs/go-ipfs#7278](https://github.com/ipfs/go-ipfs/pull/7278)) + - Docs: Delete section headers for removed features ([ipfs/go-ipfs#7277](https://github.com/ipfs/go-ipfs/pull/7277)) + - README.md: typo ([ipfs/go-ipfs#7061](https://github.com/ipfs/go-ipfs/pull/7061)) + - PR autocomment: Only comment for first-time contributors ([ipfs/go-ipfs#7270](https://github.com/ipfs/go-ipfs/pull/7270)) + - Fixed typo in config.md ([ipfs/go-ipfs#7267](https://github.com/ipfs/go-ipfs/pull/7267)) + - Fixes #7252 - Uses gabriel-vasile/mimetype to support additional content types ([ipfs/go-ipfs#7262](https://github.com/ipfs/go-ipfs/pull/7262)) + - update go-libp2p-quic-transport to v0.3.6 ([ipfs/go-ipfs#7266](https://github.com/ipfs/go-ipfs/pull/7266)) + - Updates bash completions to be compatible with zsh ([ipfs/go-ipfs#7261](https://github.com/ipfs/go-ipfs/pull/7261)) + - systemd service enhancements + run as system user ([ipfs/go-ipfs#7259](https://github.com/ipfs/go-ipfs/pull/7259)) + - upgrade to go 1.14.2 ([ipfs/go-ipfs#7130](https://github.com/ipfs/go-ipfs/pull/7130)) + - Add module files for go-ipfs-as-a-library example ([ipfs/go-ipfs#7146](https://github.com/ipfs/go-ipfs/pull/7146)) + - feat(gateway): show the absolute path and CID every time ([ipfs/go-ipfs#7219](https://github.com/ipfs/go-ipfs/pull/7219)) + - fix: do not use hard coded IPNS Publish maximum timeout duration ([ipfs/go-ipfs#7256](https://github.com/ipfs/go-ipfs/pull/7256)) + - Auto-comment on submitted PRs ([ipfs/go-ipfs#7248](https://github.com/ipfs/go-ipfs/pull/7248)) + - Fixes Github link. ([ipfs/go-ipfs#7239](https://github.com/ipfs/go-ipfs/pull/7239)) + - docs: fix subdomain examples in CHANGELOG ([ipfs/go-ipfs#7240](https://github.com/ipfs/go-ipfs/pull/7240)) + - doc: add snap to the release checklist ([ipfs/go-ipfs#7253](https://github.com/ipfs/go-ipfs/pull/7253)) + - Welcome message for users opening their first issue ([ipfs/go-ipfs#7247](https://github.com/ipfs/go-ipfs/pull/7247)) + - feat: bump to 0.6.0-dev ([ipfs/go-ipfs#7249](https://github.com/ipfs/go-ipfs/pull/7249)) +- github.com/ipfs/go-bitswap (v0.2.13 -> v0.2.19): + - fix want gauge calculation ([ipfs/go-bitswap#416](https://github.com/ipfs/go-bitswap/pull/416)) + - Fix PeerManager signalAvailabiity() race ([ipfs/go-bitswap#417](https://github.com/ipfs/go-bitswap/pull/417)) + - fix: avoid taking accessing the peerQueues without taking the lock ([ipfs/go-bitswap#412](https://github.com/ipfs/go-bitswap/pull/412)) + - fix: update circleci ci-go ([ipfs/go-bitswap#396](https://github.com/ipfs/go-bitswap/pull/396)) + - fix: only track useful received data in the ledger (#411) ([ipfs/go-bitswap#411](https://github.com/ipfs/go-bitswap/pull/411)) + - If peer is first to send a block to session, protect connection ([ipfs/go-bitswap#406](https://github.com/ipfs/go-bitswap/pull/406)) + - Ensure sessions register with PeerManager ([ipfs/go-bitswap#405](https://github.com/ipfs/go-bitswap/pull/405)) + - Total wants gauge (#402) ([ipfs/go-bitswap#402](https://github.com/ipfs/go-bitswap/pull/402)) + - Improve peer manager performance ([ipfs/go-bitswap#395](https://github.com/ipfs/go-bitswap/pull/395)) + - fix: return wants from engine.WantlistForPeer() ([ipfs/go-bitswap#390](https://github.com/ipfs/go-bitswap/pull/390)) + - Add autocomment configuration + - calculate message latency ([ipfs/go-bitswap#386](https://github.com/ipfs/go-bitswap/pull/386)) + - fix: use one less go-routine per session (#377) ([ipfs/go-bitswap#377](https://github.com/ipfs/go-bitswap/pull/377)) + - Add standard issue template +- github.com/ipfs/go-cid (v0.0.5 -> v0.0.6): + - feat: add Filecoin multicodecs ([ipfs/go-cid#104](https://github.com/ipfs/go-cid/pull/104)) + - Add autocomment configuration + - avoid calling the method WriteTo if we don't satisfy its contract ([ipfs/go-cid#103](https://github.com/ipfs/go-cid/pull/103)) + - add a couple useful methods ([ipfs/go-cid#102](https://github.com/ipfs/go-cid/pull/102)) + - Add standard issue template +- github.com/ipfs/go-fs-lock (v0.0.4 -> v0.0.5): + - chore: remove xerrors ([ipfs/go-fs-lock#15](https://github.com/ipfs/go-fs-lock/pull/15)) + - Add autocomment configuration + - Add standard issue template +- github.com/ipfs/go-ipfs-cmds (v0.2.2 -> v0.2.9): + - build(deps): bump github.com/ipfs/go-log from 1.0.3 to 1.0.4 ([ipfs/go-ipfs-cmds#194](https://github.com/ipfs/go-ipfs-cmds/pull/194)) + - Fix go-ipfs#7242: Remove "HEAD" from Allow methods ([ipfs/go-ipfs-cmds#195](https://github.com/ipfs/go-ipfs-cmds/pull/195)) + - Staticcheck fixes (#196) ([ipfs/go-ipfs-cmds#196](https://github.com/ipfs/go-ipfs-cmds/pull/196)) + - doc: update docs for interface changes ([ipfs/go-ipfs-cmds#197](https://github.com/ipfs/go-ipfs-cmds/pull/197)) + - Add standard issue template +- github.com/ipfs/go-ipfs-config (v0.5.3 -> v0.8.0): + - feat: add a transports section for enabling/disabling transports ([ipfs/go-ipfs-config#102](https://github.com/ipfs/go-ipfs-config/pull/102)) + - feat: add an option for security transport experiments ([ipfs/go-ipfs-config#97](https://github.com/ipfs/go-ipfs-config/pull/97)) + - feat: add peering service config section ([ipfs/go-ipfs-config#96](https://github.com/ipfs/go-ipfs-config/pull/96)) + - fix: include key size in key init method ([ipfs/go-ipfs-config#95](https://github.com/ipfs/go-ipfs-config/pull/95)) + - QUIC: remove experimental config option ([ipfs/go-ipfs-config#93](https://github.com/ipfs/go-ipfs-config/pull/93)) + - fix boostrap peers ([ipfs/go-ipfs-config#94](https://github.com/ipfs/go-ipfs-config/pull/94)) + - default config: add QUIC listening ports + quic to mars.i.ipfs.io ([ipfs/go-ipfs-config#91](https://github.com/ipfs/go-ipfs-config/pull/91)) + - feat: remove strict signing pubsub option. ([ipfs/go-ipfs-config#90](https://github.com/ipfs/go-ipfs-config/pull/90)) + - Add autocomment configuration + - Add Init Alternative allowing specification of ED25519 key ([ipfs/go-ipfs-config#78](https://github.com/ipfs/go-ipfs-config/pull/78)) +- github.com/ipfs/go-mfs (v0.1.1 -> v0.1.2): + - Fix incorrect mutex unlock call in File.Open ([ipfs/go-mfs#82](https://github.com/ipfs/go-mfs/pull/82)) + - Add autocomment configuration + - Add standard issue template + - test: add Directory.ListNames test ([ipfs/go-mfs#81](https://github.com/ipfs/go-mfs/pull/81)) + - doc: add a lead maintainer + - Update README.md with newer travis badge ([ipfs/go-mfs#78](https://github.com/ipfs/go-mfs/pull/78)) +- github.com/ipfs/interface-go-ipfs-core (v0.2.7 -> v0.3.0): + - add Pin.IsPinned(..) ([ipfs/interface-go-ipfs-core#50](https://github.com/ipfs/interface-go-ipfs-core/pull/50)) + - Add autocomment configuration + - Add standard issue template + - extra time for dht spin-up ([ipfs/interface-go-ipfs-core#61](https://github.com/ipfs/interface-go-ipfs-core/pull/61)) + - feat: make the CoreAPI expose a streaming pin interface ([ipfs/interface-go-ipfs-core#49](https://github.com/ipfs/interface-go-ipfs-core/pull/49)) + - test: fail early on err to avoid an unrelated panic ([ipfs/interface-go-ipfs-core#57](https://github.com/ipfs/interface-go-ipfs-core/pull/57)) +- github.com/jbenet/go-is-domain (v1.0.3 -> v1.0.5): + - Add OpenNIC domains to extended TLDs. ([jbenet/go-is-domain#15](https://github.com/jbenet/go-is-domain/pull/15)) + - feat: add .crypto and .zil from UnstoppableDomains ([jbenet/go-is-domain#17](https://github.com/jbenet/go-is-domain/pull/17)) + - chore: update IANA TLDs to version 2020051300 ([jbenet/go-is-domain#18](https://github.com/jbenet/go-is-domain/pull/18)) +- github.com/libp2p/go-addr-util (v0.0.1 -> v0.0.2): + - fix discuss badge + - add discuss link to readme + - fix: fdcostly should take only the prefix into account ([libp2p/go-addr-util#5](https://github.com/libp2p/go-addr-util/pull/5)) + - add gomod support // tag v0.0.1 ([libp2p/go-addr-util#17](https://github.com/libp2p/go-addr-util/pull/17)) +- github.com/libp2p/go-libp2p (v0.8.3 -> v0.9.6): + - fix(nat): use the right addresses when nat port mapping ([libp2p/go-libp2p#966](https://github.com/libp2p/go-libp2p/pull/966)) + - chore: update deps ([libp2p/go-libp2p#967](https://github.com/libp2p/go-libp2p/pull/967)) + - Fix peer handler race ([libp2p/go-libp2p#965](https://github.com/libp2p/go-libp2p/pull/965)) + - optimize numInbound count ([libp2p/go-libp2p#960](https://github.com/libp2p/go-libp2p/pull/960)) + - update go-libp2p-circuit ([libp2p/go-libp2p#962](https://github.com/libp2p/go-libp2p/pull/962)) + - Chunking large Identify responses with Signed Records ([libp2p/go-libp2p#958](https://github.com/libp2p/go-libp2p/pull/958)) + - gomod: update dependencies ([libp2p/go-libp2p#959](https://github.com/libp2p/go-libp2p/pull/959)) + - fixed compilation error (#956) ([libp2p/go-libp2p#956](https://github.com/libp2p/go-libp2p/pull/956)) + - Filter Interface Addresses (#936) ([libp2p/go-libp2p#936](https://github.com/libp2p/go-libp2p/pull/936)) + - fix: remove old addresses in identify immediately ([libp2p/go-libp2p#953](https://github.com/libp2p/go-libp2p/pull/953)) + - fix flaky test (#952) ([libp2p/go-libp2p#952](https://github.com/libp2p/go-libp2p/pull/952)) + - fix: group observations by zeroing port ([libp2p/go-libp2p#949](https://github.com/libp2p/go-libp2p/pull/949)) + - fix: fix connection gater in transport constructor ([libp2p/go-libp2p#948](https://github.com/libp2p/go-libp2p/pull/948)) + - Fix potential flakiness in TestIDService ([libp2p/go-libp2p#945](https://github.com/libp2p/go-libp2p/pull/945)) + - make the {F=>f}iltersConnectionGater private. (#946) ([libp2p/go-libp2p#946](https://github.com/libp2p/go-libp2p/pull/946)) + - Filter observed addresses (#917) ([libp2p/go-libp2p#917](https://github.com/libp2p/go-libp2p/pull/917)) + - fix: don't try to marshal a nil record ([libp2p/go-libp2p#943](https://github.com/libp2p/go-libp2p/pull/943)) + - add test to demo missing peer records after listen ([libp2p/go-libp2p#941](https://github.com/libp2p/go-libp2p/pull/941)) + - fix: don't leak a goroutine if a peer connects and immediately disconnects ([libp2p/go-libp2p#942](https://github.com/libp2p/go-libp2p/pull/942)) + - no signed peer records for mocknets (#934) ([libp2p/go-libp2p#934](https://github.com/libp2p/go-libp2p/pull/934)) + - implement connection gating at the top level (#881) ([libp2p/go-libp2p#881](https://github.com/libp2p/go-libp2p/pull/881)) + - various identify fixes and nits (#922) ([libp2p/go-libp2p#922](https://github.com/libp2p/go-libp2p/pull/922)) + - Remove race between ID, Push & Delta (#907) ([libp2p/go-libp2p#907](https://github.com/libp2p/go-libp2p/pull/907)) + - fix a compilation error introduced in 077a818. (#919) ([libp2p/go-libp2p#919](https://github.com/libp2p/go-libp2p/pull/919)) + - exchange signed routing records in identify (#747) ([libp2p/go-libp2p#747](https://github.com/libp2p/go-libp2p/pull/747)) +- github.com/libp2p/go-libp2p-autonat (v0.2.2 -> v0.2.3): + - react to incoming events ([libp2p/go-libp2p-autonat#65](https://github.com/libp2p/go-libp2p-autonat/pull/65)) +- github.com/libp2p/go-libp2p-blankhost (v0.1.4 -> v0.1.6): + - subscribe connmgr to net notifications ([libp2p/go-libp2p-blankhost#45](https://github.com/libp2p/go-libp2p-blankhost/pull/45)) + - add WithConnectionManager option to blankhost ([libp2p/go-libp2p-blankhost#44](https://github.com/libp2p/go-libp2p-blankhost/pull/44)) + - Blank host should support signed records ([libp2p/go-libp2p-blankhost#42](https://github.com/libp2p/go-libp2p-blankhost/pull/42)) +- github.com/libp2p/go-libp2p-circuit (v0.2.2 -> v0.2.3): + - Use a fixed connection manager weight for peers with relay connections ([libp2p/go-libp2p-circuit#119](https://github.com/libp2p/go-libp2p-circuit/pull/119)) +- github.com/libp2p/go-libp2p-connmgr (v0.2.1 -> v0.2.4): + - Implement IsProtected interface ([libp2p/go-libp2p-connmgr#76](https://github.com/libp2p/go-libp2p-connmgr/pull/76)) + - decaying tags: support removal and closure. (#72) ([libp2p/go-libp2p-connmgr#72](https://github.com/libp2p/go-libp2p-connmgr/pull/72)) + - implement decaying tags. (#61) ([libp2p/go-libp2p-connmgr#61](https://github.com/libp2p/go-libp2p-connmgr/pull/61)) +- github.com/libp2p/go-libp2p-core (v0.5.3 -> v0.5.7): + - connmgr: add IsProtected interface (#158) ([libp2p/go-libp2p-core#158](https://github.com/libp2p/go-libp2p-core/pull/158)) + - eventbus: add wildcard subscription type; getter to enumerate known types (#153) ([libp2p/go-libp2p-core#153](https://github.com/libp2p/go-libp2p-core/pull/153)) + - events: add a generic DHT event. (#154) ([libp2p/go-libp2p-core#154](https://github.com/libp2p/go-libp2p-core/pull/154)) + - decaying tags: support removal and closure. (#151) ([libp2p/go-libp2p-core#151](https://github.com/libp2p/go-libp2p-core/pull/151)) + - implement Stringer for network.{Direction,Connectedness,Reachability}. (#150) ([libp2p/go-libp2p-core#150](https://github.com/libp2p/go-libp2p-core/pull/150)) + - connmgr: introduce abstractions and functions for decaying tags. (#104) ([libp2p/go-libp2p-core#104](https://github.com/libp2p/go-libp2p-core/pull/104)) + - Interface to verify if a peer supports a protocol without making allocations. ([libp2p/go-libp2p-core#148](https://github.com/libp2p/go-libp2p-core/pull/148)) + - add connection gating interfaces and types. (#139) ([libp2p/go-libp2p-core#139](https://github.com/libp2p/go-libp2p-core/pull/139)) +- github.com/libp2p/go-libp2p-kad-dht (v0.7.11 -> v0.8.2): + - feat: protect all peers in low buckets, tag everyone else with 5 + - fix: lookup context cancellation race condition ([libp2p/go-libp2p-kad-dht#656](https://github.com/libp2p/go-libp2p-kad-dht/pull/656)) + - fix: protect useful peers in low buckets ([libp2p/go-libp2p-kad-dht#634](https://github.com/libp2p/go-libp2p-kad-dht/pull/634)) + - Double the usefulness interval for peers in the Routing Table (#651) ([libp2p/go-libp2p-kad-dht#651](https://github.com/libp2p/go-libp2p-kad-dht/pull/651)) + - enhancement/remove-unused-variable ([libp2p/go-libp2p-kad-dht#633](https://github.com/libp2p/go-libp2p-kad-dht/pull/633)) + - Put back TestSelfWalkOnAddressChange ([libp2p/go-libp2p-kad-dht#648](https://github.com/libp2p/go-libp2p-kad-dht/pull/648)) + - Routing Table Refresh manager (#601) ([libp2p/go-libp2p-kad-dht#601](https://github.com/libp2p/go-libp2p-kad-dht/pull/601)) + - Boostrap empty RT and Optimize allocs when we discover new peers (#631) ([libp2p/go-libp2p-kad-dht#631](https://github.com/libp2p/go-libp2p-kad-dht/pull/631)) + - fix all flaky tests ([libp2p/go-libp2p-kad-dht#628](https://github.com/libp2p/go-libp2p-kad-dht/pull/628)) + - Update default concurrency parameter ([libp2p/go-libp2p-kad-dht#605](https://github.com/libp2p/go-libp2p-kad-dht/pull/605)) + - clean up a channel that was dangling ([libp2p/go-libp2p-kad-dht#620](https://github.com/libp2p/go-libp2p-kad-dht/pull/620)) +- github.com/libp2p/go-libp2p-kbucket (v0.4.1 -> v0.4.2): + - Reduce allocs in AddPeer (#81) ([libp2p/go-libp2p-kbucket#81](https://github.com/libp2p/go-libp2p-kbucket/pull/81)) + - NPeersForCpl and collapse empty buckets (#77) ([libp2p/go-libp2p-kbucket#77](https://github.com/libp2p/go-libp2p-kbucket/pull/77)) +- github.com/libp2p/go-libp2p-peerstore (v0.2.3 -> v0.2.6): + - fix two bugs in signed address handling ([libp2p/go-libp2p-peerstore#155](https://github.com/libp2p/go-libp2p-peerstore/pull/155)) + - addrbook: fix races ([libp2p/go-libp2p-peerstore#154](https://github.com/libp2p/go-libp2p-peerstore/pull/154)) + - Implement the FirstSupportedProtocol API. ([libp2p/go-libp2p-peerstore#147](https://github.com/libp2p/go-libp2p-peerstore/pull/147)) +- github.com/libp2p/go-libp2p-pubsub (v0.2.7 -> v0.3.1): + - fix outbound constraint satisfaction in oversubscription pruning + - Gossipsub v0.3.0 + - set sendTo to remote peer id in trace events ([libp2p/go-libp2p-pubsub#268](https://github.com/libp2p/go-libp2p-pubsub/pull/268)) + - make wire protocol message size configurable. (#261) ([libp2p/go-libp2p-pubsub#261](https://github.com/libp2p/go-libp2p-pubsub/pull/261)) +- github.com/libp2p/go-libp2p-pubsub-router (v0.2.1 -> v0.3.0): + - feat: update pubsub ([libp2p/go-libp2p-pubsub-router#76](https://github.com/libp2p/go-libp2p-pubsub-router/pull/76)) +- github.com/libp2p/go-libp2p-quic-transport (v0.3.7 -> v0.5.1): + - close the connection when it is refused by InterceptSecured ([libp2p/go-libp2p-quic-transport#157](https://github.com/libp2p/go-libp2p-quic-transport/pull/157)) + - gate QUIC connections via new ConnectionGater (#152) ([libp2p/go-libp2p-quic-transport#152](https://github.com/libp2p/go-libp2p-quic-transport/pull/152)) +- github.com/libp2p/go-libp2p-record (v0.1.2 -> v0.1.3): + - feat: add a better record error ([libp2p/go-libp2p-record#39](https://github.com/libp2p/go-libp2p-record/pull/39)) +- github.com/libp2p/go-libp2p-swarm (v0.2.3 -> v0.2.6): + - Configure private key for test swarm ([libp2p/go-libp2p-swarm#223](https://github.com/libp2p/go-libp2p-swarm/pull/223)) + - Rank Dial addresses (#212) ([libp2p/go-libp2p-swarm#212](https://github.com/libp2p/go-libp2p-swarm/pull/212)) + - implement connection gating support: intercept peer, address dials, upgraded conns (#201) ([libp2p/go-libp2p-swarm#201](https://github.com/libp2p/go-libp2p-swarm/pull/201)) + - fix: avoid calling AddChild after the process may shutdown. ([libp2p/go-libp2p-swarm#207](https://github.com/libp2p/go-libp2p-swarm/pull/207)) +- github.com/libp2p/go-libp2p-transport-upgrader (v0.2.0 -> v0.3.0): + - call the connection gater when accepting connections and after crypto handshake (#55) ([libp2p/go-libp2p-transport-upgrader#55](https://github.com/libp2p/go-libp2p-transport-upgrader/pull/55)) +- github.com/libp2p/go-openssl (v0.0.4 -> v0.0.5): + - add binding for OBJ_create ([libp2p/go-openssl#5](https://github.com/libp2p/go-openssl/pull/5)) +- github.com/libp2p/go-yamux (v1.3.5 -> v1.3.7): + - tighten lock around appending new chunks of read data in stream ([libp2p/go-yamux#28](https://github.com/libp2p/go-yamux/pull/28)) + - fix: unlock recvLock in all cases. ([libp2p/go-yamux#25](https://github.com/libp2p/go-yamux/pull/25)) +- github.com/lucas-clemente/quic-go (v0.15.7 -> v0.16.2): + - make it possible to use the transport with both draft-28 and draft-29 + - update the ALPN for draft-29 ([lucas-clemente/quic-go#2600](https://github.com/lucas-clemente/quic-go/pull/2600)) + - update initial salts and test vectors for draft-29 ([lucas-clemente/quic-go#2587](https://github.com/lucas-clemente/quic-go/pull/2587)) + - rename the SERVER_BUSY error to CONNECTION_REFUSED ([lucas-clemente/quic-go#2596](https://github.com/lucas-clemente/quic-go/pull/2596)) + - reduce calls to time.Now() from the flow controller ([lucas-clemente/quic-go#2591](https://github.com/lucas-clemente/quic-go/pull/2591)) + - remove redundant parenthesis and type conversion in flow controller ([lucas-clemente/quic-go#2592](https://github.com/lucas-clemente/quic-go/pull/2592)) + - use the receipt of a Retry packet to get a first RTT estimate ([lucas-clemente/quic-go#2588](https://github.com/lucas-clemente/quic-go/pull/2588)) + - fix debug message when returning an early session ([lucas-clemente/quic-go#2594](https://github.com/lucas-clemente/quic-go/pull/2594)) + - fix closing of the http.Request.Body ([lucas-clemente/quic-go#2584](https://github.com/lucas-clemente/quic-go/pull/2584)) + - split PTO calculation into a separate function ([lucas-clemente/quic-go#2576](https://github.com/lucas-clemente/quic-go/pull/2576)) + - add a unit test using the ChaCha20 test vector from the draft ([lucas-clemente/quic-go#2585](https://github.com/lucas-clemente/quic-go/pull/2585)) + - fix seed generation in frame sorter tests ([lucas-clemente/quic-go#2583](https://github.com/lucas-clemente/quic-go/pull/2583)) + - make sure that ACK frames are bundled with data ([lucas-clemente/quic-go#2543](https://github.com/lucas-clemente/quic-go/pull/2543)) + - add a Changelog for v0.16 ([lucas-clemente/quic-go#2582](https://github.com/lucas-clemente/quic-go/pull/2582)) + - authenticate connection IDs ([lucas-clemente/quic-go#2567](https://github.com/lucas-clemente/quic-go/pull/2567)) + - don't switch to PTO mode after using early loss detection ([lucas-clemente/quic-go#2581](https://github.com/lucas-clemente/quic-go/pull/2581)) + - only create a single session for duplicate Initials ([lucas-clemente/quic-go#2580](https://github.com/lucas-clemente/quic-go/pull/2580)) + - fix broken unit test in ackhandler + - update the ALPN tokens to draft-28 ([lucas-clemente/quic-go#2570](https://github.com/lucas-clemente/quic-go/pull/2570)) + - drop duplicate packets ([lucas-clemente/quic-go#2569](https://github.com/lucas-clemente/quic-go/pull/2569)) + - remove noisy log statement in frame sorter test ([lucas-clemente/quic-go#2571](https://github.com/lucas-clemente/quic-go/pull/2571)) + - fix flaky qlog unit tests ([lucas-clemente/quic-go#2572](https://github.com/lucas-clemente/quic-go/pull/2572)) + - implement the 3x amplification limit ([lucas-clemente/quic-go#2536](https://github.com/lucas-clemente/quic-go/pull/2536)) + - rewrite the frame sorter ([lucas-clemente/quic-go#2561](https://github.com/lucas-clemente/quic-go/pull/2561)) + - retire conn IDs with sequence numbers smaller than the currently active ([lucas-clemente/quic-go#2563](https://github.com/lucas-clemente/quic-go/pull/2563)) + - remove unused readOffset member variable in receiveStream ([lucas-clemente/quic-go#2559](https://github.com/lucas-clemente/quic-go/pull/2559)) + - fix int overflow when parsing the transport parameters ([lucas-clemente/quic-go#2564](https://github.com/lucas-clemente/quic-go/pull/2564)) + - use struct{} instead of bool in window update queue ([lucas-clemente/quic-go#2555](https://github.com/lucas-clemente/quic-go/pull/2555)) + - update the protobuf library to google.golang.org/protobuf/proto ([lucas-clemente/quic-go#2554](https://github.com/lucas-clemente/quic-go/pull/2554)) + - use the correct error code for crypto stream errors ([lucas-clemente/quic-go#2546](https://github.com/lucas-clemente/quic-go/pull/2546)) + - bundle small writes on streams ([lucas-clemente/quic-go#2538](https://github.com/lucas-clemente/quic-go/pull/2538)) + - reduce the length of the unprocessed packet chan in the session ([lucas-clemente/quic-go#2534](https://github.com/lucas-clemente/quic-go/pull/2534)) + - fix flaky session unit test ([lucas-clemente/quic-go#2537](https://github.com/lucas-clemente/quic-go/pull/2537)) + - add a send stream test that randomly acknowledges and loses data ([lucas-clemente/quic-go#2535](https://github.com/lucas-clemente/quic-go/pull/2535)) + - fix size calculation for version negotiation packets ([lucas-clemente/quic-go#2542](https://github.com/lucas-clemente/quic-go/pull/2542)) + - run all unit tests with race detector ([lucas-clemente/quic-go#2528](https://github.com/lucas-clemente/quic-go/pull/2528)) + - add support for the ChaCha20 interop test case ([lucas-clemente/quic-go#2517](https://github.com/lucas-clemente/quic-go/pull/2517)) + - fix buffer use after it was released when sending an INVALID_TOKEN error ([lucas-clemente/quic-go#2524](https://github.com/lucas-clemente/quic-go/pull/2524)) + - run the internal and http3 tests with race detector on Travis ([lucas-clemente/quic-go#2385](https://github.com/lucas-clemente/quic-go/pull/2385)) + - reset the PTO when dropping a packet number space ([lucas-clemente/quic-go#2527](https://github.com/lucas-clemente/quic-go/pull/2527)) + - stop the deadline timer in Stream.Read and Write ([lucas-clemente/quic-go#2519](https://github.com/lucas-clemente/quic-go/pull/2519)) + - don't reset pto_count on Initial ACKs ([lucas-clemente/quic-go#2513](https://github.com/lucas-clemente/quic-go/pull/2513)) + - fix all race conditions in the session tests ([lucas-clemente/quic-go#2525](https://github.com/lucas-clemente/quic-go/pull/2525)) + - make sure that the server's run loop returned when closing ([lucas-clemente/quic-go#2526](https://github.com/lucas-clemente/quic-go/pull/2526)) + - fix flaky proxy test ([lucas-clemente/quic-go#2522](https://github.com/lucas-clemente/quic-go/pull/2522)) + - stop the timer when the session's run loop returns ([lucas-clemente/quic-go#2516](https://github.com/lucas-clemente/quic-go/pull/2516)) + - make it more likely that a STREAM frame is bundled with the FIN ([lucas-clemente/quic-go#2504](https://github.com/lucas-clemente/quic-go/pull/2504)) +- github.com/multiformats/go-multiaddr (v0.2.1 -> v0.2.2): + - absorb go-maddr-filter; rm stale Makefile targets; upgrade deps (#124) ([multiformats/go-multiaddr#124](https://github.com/multiformats/go-multiaddr/pull/124)) +- github.com/multiformats/go-multibase (v0.0.2 -> v0.0.3): + - Base36 implementation ([multiformats/go-multibase#36](https://github.com/multiformats/go-multibase/pull/36)) + - Even more tests/benchmarks, less repetition in-code ([multiformats/go-multibase#34](https://github.com/multiformats/go-multibase/pull/34)) + - Beef up tests before adding new codec ([multiformats/go-multibase#32](https://github.com/multiformats/go-multibase/pull/32)) + - Remove GX, bump spec submodule, fix tests ([multiformats/go-multibase#31](https://github.com/multiformats/go-multibase/pull/31)) + +### Contributors + +| Contributor | Commits | Lines ± | Files Changed | +|-------------------------|---------|-------------|---------------| +| vyzo | 224 | +8016/-2810 | 304 | +| Marten Seemann | 87 | +6081/-2607 | 215 | +| Steven Allen | 157 | +4763/-1628 | 266 | +| Aarsh Shah | 33 | +4619/-1634 | 128 | +| Dirk McCormick | 26 | +3596/-1156 | 69 | +| Yusef Napora | 66 | +2622/-785 | 98 | +| Raúl Kripalani | 24 | +2424/-782 | 61 | +| Hector Sanjuan | 30 | +999/-177 | 61 | +| Louis Thibault | 2 | +1111/-4 | 4 | +| Will Scott | 15 | +717/-219 | 31 | +| dependabot-preview[bot] | 53 | +640/-64 | 106 | +| Michael Muré | 7 | +456/-213 | 17 | +| David Dias | 11 | +426/-88 | 15 | +| Peter Rabbitson | 11 | +254/-189 | 31 | +| Lukasz Zimnoch | 9 | +361/-49 | 13 | +| Jakub Sztandera | 4 | +157/-104 | 9 | +| Rod Vagg | 1 | +91/-83 | 2 | +| RubenKelevra | 13 | +84/-84 | 30 | +| JP Hastings-Spital | 1 | +145/-0 | 2 | +| Adin Schmahmann | 11 | +67/-37 | 15 | +| Marcin Rataj | 11 | +41/-43 | 11 | +| Tiger | 5 | +53/-8 | 6 | +| Akira | 2 | +35/-19 | 2 | +| Casey Chance | 2 | +31/-22 | 2 | +| Alan Shaw | 1 | +44/-0 | 2 | +| Jessica Schilling | 4 | +20/-19 | 7 | +| Gowtham G | 4 | +22/-14 | 6 | +| Jeromy Johnson | 3 | +24/-6 | 3 | +| Edgar Aroutiounian | 3 | +16/-8 | 3 | +| Peter Wu | 2 | +12/-9 | 2 | +| Sawood Alam | 2 | +7/-7 | 2 | +| Command | 1 | +12/-0 | 1 | +| Eric Myhre | 1 | +9/-2 | 1 | +| mawei | 2 | +5/-5 | 2 | +| decanus | 1 | +5/-5 | 1 | +| Ignacio Hagopian | 2 | +7/-2 | 2 | +| Alfonso Montero | 1 | +1/-5 | 1 | +| Volker Mische | 1 | +2/-2 | 1 | +| Shotaro Yamada | 1 | +2/-1 | 1 | +| Mark Gaiser | 1 | +1/-1 | 1 | +| Johnny | 1 | +1/-1 | 1 | +| Ganesh Prasad Kumble | 1 | +1/-1 | 1 | +| Dominic Della Valle | 1 | +1/-1 | 1 | +| Corbin Page | 1 | +1/-1 | 1 | +| Bryan Stenson | 1 | +1/-1 | 1 | +| Bernhard M. Wiedemann | 1 | +1/-1 | 1 | + ## 0.5.1 2020-05-08 Hot on the heels of 0.5.0 is 0.5.1 with some important but small bug fixes. This release: @@ -262,13 +664,13 @@ In addition to a bunch of bug fixes, we've made two improvements to the gateway. You can play with both of these features by visiting: -> http://bafybeia6po64b6tfqq73lckadrhpihg2oubaxgqaoushquhcek46y3zumm.ipfs.io/ +> http://bafybeia6po64b6tfqq73lckadrhpihg2oubaxgqaoushquhcek46y3zumm.ipfs.localhost:8080 ##### Subdomain Gateway First up, we've changed how URLs in the IPFS gateway work for better browser security. The gateway will now redirect from -`http://localhost:5001/ipfs/CID/...` to `http://CID.ipfs.localhost:5001/...` by +`http://localhost:8080/ipfs/CID/...` to `http://CID.ipfs.localhost:8080/...` by default. This: * Ensures that every dapp gets its own browser origin. @@ -282,7 +684,7 @@ Note: cURL doesn't follow redirects by default. To avoid breaking cURL and other The second feature is a face-lift to the directory listing theme and color palette. -> http://bafybeia6po64b6tfqq73lckadrhpihg2oubaxgqaoushquhcek46y3zumm.ipfs.io/ +> http://bafybeia6po64b6tfqq73lckadrhpihg2oubaxgqaoushquhcek46y3zumm.ipfs.localhost:8080 #### IPNS @@ -290,7 +692,7 @@ This release includes several new IPNS and IPNS-related features. ##### ENS -IPFS now resolves [ENS](https://ens.domains/) names (e.g., [/ipns/ipfs.eth](https://ipfs.eth.dweb.link)) via DNSLink. +IPFS now resolves [ENS](https://ens.domains/) names (e.g., `/ipns/ipfs.eth`) via DNSLink provided by https://eth.link service. ##### IPNS over PubSub @@ -662,7 +1064,7 @@ As usual, this release contains several Windows specific fixes and improvements: - fix #2203: omit the charset attribute when Content-Type is text/html ([ipfs/go-ipfs#6743](https://github.com/ipfs/go-ipfs/pull/6743)) - Pin ls traverses all indirect pins ([ipfs/go-ipfs#6705](https://github.com/ipfs/go-ipfs/pull/6705)) - fix: ignore nonexistant when force rm ([ipfs/go-ipfs#6773](https://github.com/ipfs/go-ipfs/pull/6773)) - - introduce IpfsNode Plugin ([ipfs/go-ipfs#6719](https://githung b.com/ipfs/go-ipfs/pull/6719)) + - introduce IpfsNode Plugin ([ipfs/go-ipfs#6719](https://github.com/ipfs/go-ipfs/pull/6719)) - improve documentation and fix dht put bug ([ipfs/go-ipfs#6750](https://github.com/ipfs/go-ipfs/pull/6750)) - Adding alias for `ipfs repo stat`. ([ipfs/go-ipfs#6769](https://github.com/ipfs/go-ipfs/pull/6769)) - doc(gateway): document dnslink ([ipfs/go-ipfs#6767](https://github.com/ipfs/go-ipfs/pull/6767)) diff --git a/Dockerfile b/Dockerfile index 7f35a01fbcd..823240dddaf 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,4 +1,4 @@ -FROM golang:1.13.10-buster +FROM golang:1.14.2-buster LABEL maintainer="Steven Allen " # Install deps @@ -23,7 +23,7 @@ ARG IPFS_PLUGINS # Build the thing. # Also: fix getting HEAD commit hash via git rev-parse. RUN cd $SRC_DIR \ - && mkdir .git/objects \ + && mkdir -p .git/objects \ && make build GOTAGS=openssl IPFS_PLUGINS=$IPFS_PLUGINS # Get su-exec, a very minimal tool for dropping privileges, @@ -73,6 +73,8 @@ COPY --from=0 /usr/lib/*-linux-gnu*/libcrypto.so* /usr/lib/ # Swarm TCP; should be exposed to the public EXPOSE 4001 +# Swarm UDP; should be exposed to the public +EXPOSE 4001/udp # Daemon API; must not be exposed publicly but to client services under you control EXPOSE 5001 # Web Gateway; can be exposed publicly with a proxy, e.g. as https://ipfs.example.org diff --git a/README.md b/README.md index 77ce644c377..ae3b36f2004 100644 --- a/README.md +++ b/README.md @@ -12,7 +12,7 @@ ## What is IPFS? -IPFS is a global, versioned, peer-to-peer filesystem. It combines good ideas from previous systems such Git, BitTorrent, Kademlia, SFS, and the Web. It is like a single bittorrent swarm, exchanging git objects. IPFS provides an interface as simple as the HTTP web, but with permanence built in. You can also mount the world at /ipfs. +IPFS is a global, versioned, peer-to-peer filesystem. It combines good ideas from previous systems such as Git, BitTorrent, Kademlia, SFS, and the Web. It is like a single BitTorrent swarm, exchanging git objects. IPFS provides an interface as simple as the HTTP web, but with permanence built-in. You can also mount the world at /ipfs. For more info see: https://docs.ipfs.io/introduction/overview/ @@ -64,7 +64,7 @@ The canonical download instructions for IPFS are over at: https://docs.ipfs.io/g IPFS can run on most Linux, macOS, and Windows systems. We recommend running it on a machine with at least 2 GB of RAM and 2 CPU cores (go-ipfs is highly parallel). On systems with less memory, it may not be completely stable. -If your system is resource constrained, we recommend: +If your system is resource-constrained, we recommend: 1. Installing OpenSSL and rebuilding go-ipfs manually with `make build GOTAGS=openssl`. See the [download and compile](#download-and-compile-ipfs) section for more information on compiling go-ipfs. 2. Initializing your daemon with `ipfs init --profile=lowpower` @@ -98,7 +98,7 @@ $ sudo pacman -S go-ipfs Development version of go-ipfs is also on AUR under [go-ipfs-git](https://aur.archlinux.org/packages/go-ipfs-git/). -You can install it using your favourite AUR Helper or manually from AUR. +You can install it using your favorite AUR Helper or manually from AUR. #### Nix @@ -160,7 +160,7 @@ PS> scoop install go-ipfs ### Build from Source -go-ipfs's build system requires Go 1.13 and some standard POSIX build tools: +go-ipfs's build system requires Go 1.14.2 and some standard POSIX build tools: * GNU make * Git @@ -170,7 +170,7 @@ To build without GCC, build with `CGO_ENABLED=0` (e.g., `make build CGO_ENABLED= #### Install Go -The build process for ipfs requires Go 1.12 or higher. If you don't have it: [Download Go 1.12+](https://golang.org/dl/). +The build process for ipfs requires Go 1.14.2 or higher. If you don't have it: [Download Go 1.14+](https://golang.org/dl/). You'll need to add Go's bin directories to your `$PATH` environment variable e.g., by adding these lines to your `/etc/profile` (for a system-wide installation) or `$HOME/.profile`: @@ -206,7 +206,7 @@ make build GOOS=myTargetOS GOARCH=myTargetArchitecture To build go-ipfs with OpenSSL support, append `GOTAGS=openssl` to your `make` invocation. Building with OpenSSL should significantly reduce the background CPU usage on nodes that frequently make or receive new connections. -Note: OpenSSL requires CGO support and, by default, CGO is disabled when cross compiling. To cross compile with OpenSSL support, you must: +Note: OpenSSL requires CGO support and, by default, CGO is disabled when cross-compiling. To cross-compile with OpenSSL support, you must: 1. Install a compiler toolchain for the target platform. 2. Set the `CGO_ENABLED=1` environment variable. @@ -273,11 +273,11 @@ the optional arguments it takes. After initialization is complete, you can use Basic proof of 'ipfs working' locally: - echo "hello world" > hello - ipfs add hello - # This should output a hash string that looks something like: - # QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o - ipfs cat + echo "hello world" > hello + ipfs add hello + # This should output a hash string that looks something like: + # QmT78zSuBmuS4z925WZfrqQ1qHaJ56DQaTfyMUF7F8ff5o + ipfs cat ### Usage @@ -302,7 +302,7 @@ SUBCOMMANDS ADVANCED COMMANDS daemon Start a long-running daemon process - mount Mount an ipfs read-only mountpoint + mount Mount an ipfs read-only mount point resolve Resolve any type of name name Publish or resolve IPNS names dns Resolve DNS links @@ -325,8 +325,8 @@ SUBCOMMANDS Use 'ipfs --help' to learn more about each command. - ipfs uses a repository in the local file system. By default, the repo is located - at ~/.ipfs. To change the repo location, set the $IPFS_PATH environment variable: + ipfs uses a repository in the local file system. By default, the repo is located at + ~/.ipfs. To change the repo location, set the $IPFS_PATH environment variable: export IPFS_PATH=/path/to/ipfsrepo ``` @@ -344,7 +344,7 @@ IPFS files that will persist when you restart the container. Start a container running ipfs and expose ports 4001, 5001 and 8080: - docker run -d --name ipfs_host -v $ipfs_staging:/export -v $ipfs_data:/data/ipfs -p 4001:4001 -p 127.0.0.1:8080:8080 -p 127.0.0.1:5001:5001 ipfs/go-ipfs:latest + docker run -d --name ipfs_host -v $ipfs_staging:/export -v $ipfs_data:/data/ipfs -p 4001:4001 -p 4001:4001/udp -p 127.0.0.1:8080:8080 -p 127.0.0.1:5001:5001 ipfs/go-ipfs:latest Watch the ipfs log: @@ -376,16 +376,16 @@ Stop the running container: When starting a container running ipfs for the first time with an empty data directory, it will call `ipfs init` to initialize configuration files and generate a new keypair. At this time, you can choose which profile to apply using the `IPFS_PROFILE` environment variable: - docker run -d --name ipfs_host -e IPFS_PROFILE=server -v $ipfs_staging:/export -v $ipfs_data:/data/ipfs -p 4001:4001 -p 127.0.0.1:8080:8080 -p 127.0.0.1:5001:5001 ipfs/go-ipfs:latest + docker run -d --name ipfs_host -e IPFS_PROFILE=server -v $ipfs_staging:/export -v $ipfs_data:/data/ipfs -p 4001:4001 -p 4001:4001/udp -p 127.0.0.1:8080:8080 -p 127.0.0.1:5001:5001 ipfs/go-ipfs:latest It is possible to initialize the container with a swarm key file (`/data/ipfs/swarm.key`) using the variables `IPFS_SWARM_KEY` and `IPFS_SWARM_KEY_FILE`. The `IPFS_SWARM_KEY` creates `swarm.key` with the contents of the variable itself, whilst `IPFS_SWARM_KEY_FILE` copies the key from a path stored in the variable. The `IPFS_SWARM_KEY_FILE` **overwrites** the key generated by `IPFS_SWARM_KEY`. - docker run -d --name ipfs_host -e IPFS_SWARM_KEY= -v $ipfs_staging:/export -v $ipfs_data:/data/ipfs -p 4001:4001 -p 127.0.0.1:8080:8080 -p 127.0.0.1:5001:5001 ipfs/go-ipfs:latest + docker run -d --name ipfs_host -e IPFS_SWARM_KEY= -v $ipfs_staging:/export -v $ipfs_data:/data/ipfs -p 4001:4001 -p 4001:4001/udp -p 127.0.0.1:8080:8080 -p 127.0.0.1:5001:5001 ipfs/go-ipfs:latest The swarm key initialization can also be done using docker secrets **(requires docker swarm or docker-compose)**: cat your_swarm.key | docker secret create swarm_key_secret - - docker run -d --name ipfs_host --secret swarm_key_secret -e IPFS_SWARM_KEY_FILE=/run/secrets/swarm_key_secret -v $ipfs_staging:/export -v $ipfs_data:/data/ipfs -p 4001:4001 -p 127.0.0.1:8080:8080 -p 127.0.0.1:5001:5001 ipfs/go-ipfs:latest + docker run -d --name ipfs_host --secret swarm_key_secret -e IPFS_SWARM_KEY_FILE=/run/secrets/swarm_key_secret -v $ipfs_staging:/export -v $ipfs_data:/data/ipfs -p 4001:4001 -p 4001:4001/udp -p 127.0.0.1:8080:8080 -p 127.0.0.1:5001:5001 ipfs/go-ipfs:latest ### Troubleshooting diff --git a/assets/README.md b/assets/README.md index 33b303fcb44..d365104e417 100644 --- a/assets/README.md +++ b/assets/README.md @@ -39,12 +39,13 @@ dir-index-html. > git commit -m 'chore: update dir-index-html to vX.Y.Z' ``` -Finally, re-generate the directory index HTML template and amend the previous +Finally, re-generate the directory index HTML template, tidy, and amend the previous commit. ```bash > go generate . > git add bindata.go +> go mod tidy > git commit --amend --no-edit ``` diff --git a/assets/assets.go b/assets/assets.go index f3f5de06948..51c3981c880 100644 --- a/assets/assets.go +++ b/assets/assets.go @@ -1,6 +1,8 @@ //go:generate git submodule update --init ./dir-index-html //go:generate go run github.com/go-bindata/go-bindata/go-bindata -pkg=assets init-doc dir-index-html/dir-index.html dir-index-html/knownIcons.txt //go:generate gofmt -w bindata.go +//go:generate sh -c "sed -i \"s/.*BindataVersionHash.*/BindataVersionHash=\\\"$(git hash-object bindata.go)\\\"/\" bindata_version_hash.go" +//go:generate gofmt -w bindata_version_hash.go package assets import ( diff --git a/assets/bindata.go b/assets/bindata.go index d46c608276e..c1aa0601ac3 100644 --- a/assets/bindata.go +++ b/assets/bindata.go @@ -100,7 +100,7 @@ func initDocAbout() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init-doc/about", size: 1681, mode: os.FileMode(420), modTime: time.Unix(1587436780, 0)} + info := bindataFileInfo{name: "init-doc/about", size: 1681, mode: os.FileMode(420), modTime: time.Unix(1588699613, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -120,7 +120,7 @@ func initDocContact() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init-doc/contact", size: 189, mode: os.FileMode(384), modTime: time.Unix(1568932423, 0)} + info := bindataFileInfo{name: "init-doc/contact", size: 189, mode: os.FileMode(420), modTime: time.Unix(1588699613, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -140,7 +140,7 @@ func initDocHelp() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init-doc/help", size: 311, mode: os.FileMode(420), modTime: time.Unix(1587436780, 0)} + info := bindataFileInfo{name: "init-doc/help", size: 311, mode: os.FileMode(420), modTime: time.Unix(1588699613, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -160,7 +160,7 @@ func initDocPing() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init-doc/ping", size: 4, mode: os.FileMode(384), modTime: time.Unix(1575854776, 0)} + info := bindataFileInfo{name: "init-doc/ping", size: 4, mode: os.FileMode(420), modTime: time.Unix(1588699613, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -180,7 +180,7 @@ func initDocQuickStart() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init-doc/quick-start", size: 1681, mode: os.FileMode(420), modTime: time.Unix(1587436780, 0)} + info := bindataFileInfo{name: "init-doc/quick-start", size: 1681, mode: os.FileMode(420), modTime: time.Unix(1588699613, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -200,7 +200,7 @@ func initDocReadme() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init-doc/readme", size: 1091, mode: os.FileMode(384), modTime: time.Unix(1568932423, 0)} + info := bindataFileInfo{name: "init-doc/readme", size: 1091, mode: os.FileMode(420), modTime: time.Unix(1588699613, 0)} a := &asset{bytes: bytes, info: info} return a, nil } @@ -220,12 +220,12 @@ func initDocSecurityNotes() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "init-doc/security-notes", size: 1162, mode: os.FileMode(384), modTime: time.Unix(1575854776, 0)} + info := bindataFileInfo{name: "init-doc/security-notes", size: 1162, mode: os.FileMode(420), modTime: time.Unix(1588699613, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _dirIndexHtmlDirIndexHtml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\xfc\xf7\xce\xe4\x48\x92\x27\x8a\xfe\xbf\x4f\x91\xd3\x83\x45\x77\x4f\x54\x16\x19\x94\xc1\xac\xdd\xbe\x43\xad\x83\x5a\x5e\x1c\x2c\xa8\xb5\xd6\x2c\xd4\xbb\x1f\x64\x96\xca\x9a\xee\x1e\xcc\x60\x0b\x38\xf5\x11\x1f\x82\xee\x6e\x66\x6e\xee\x6e\xf6\x33\x73\x3a\x23\xfe\xd7\xbf\x30\x1a\x6d\x07\x3a\xfb\xa1\x5c\xbb\xf6\x6f\xff\xe3\x7f\xfd\xfc\x91\x45\xe9\xdf\xfe\xc7\x87\x0f\xff\xab\xcb\xd6\xe8\x43\x52\x46\xf3\x92\xad\xff\xfb\x4f\xdb\x9a\x7f\x7c\xfd\xe9\x03\xf0\xa5\xe9\x5f\x3e\x7e\xfc\x50\x66\xed\x98\xcd\x1f\xd6\xe1\x43\x32\xf4\xcb\x3a\x6f\xc9\xfa\x61\x2d\xab\xe5\x43\xb5\x7c\x28\xb3\x39\xfb\xf4\xa1\x5c\xd7\x71\xf9\x04\x00\x45\xb5\x96\x5b\xfc\x6d\x32\x74\x40\x32\x5f\xe3\x5a\x9d\x40\x76\x8e\x40\xdc\x0e\x31\xd0\x45\xcb\x9a\xcd\x40\xd5\x15\xd9\x62\x0f\xb4\x65\x31\xd1\x1a\x01\xc9\xd0\xef\xd9\xbc\x7e\x5b\x0c\x1f\x3e\x7e\xfc\xd2\xe3\xb2\x5e\x6d\xf6\xf9\xee\xb3\x96\xdf\xe7\x43\xbf\x7e\xcc\xa3\xae\x6a\xaf\x4f\x4b\xd4\x2f\x1f\x97\x6c\xae\xf2\xef\x3e\x1e\x59\xdc\x54\xeb\xc7\x35\x3b\xd7\x8f\x4b\x75\x67\x1f\xa3\xb4\xde\x96\xf5\xd3\x13\x04\xff\xe7\x77\x1f\xbb\xe5\x1f\xb7\xfc\x10\x0f\xe9\xf5\x7d\x17\xcd\x45\xd5\x7f\x02\x7f\x88\xbe\x8f\xa3\xa4\x29\xe6\x61\xeb\xd3\x8f\xc9\xd0\x0e\xf3\xa7\x75\x8e\xfa\x65\x8c\xe6\xac\x5f\x7f\x88\x3e\x45\xc9\x5a\xed\xd9\x37\xd1\xa7\x72\xd8\xb3\xf9\xfb\x61\x5b\xdb\xaa\xcf\x3e\x81\x3f\x2c\xeb\x3c\xf4\xc5\x8f\xda\x1d\x59\x55\x94\xeb\x27\x1c\x04\x7f\x88\xb7\x75\x1d\xfa\x4f\x9f\x3e\x76\xc3\xfd\x31\x1f\x92\x6d\xf9\x58\xf5\x7d\x36\x7f\x53\xf5\xe3\xb6\xfe\x7d\xfd\xf7\x63\x94\xa6\x55\x5f\x7c\x02\xbf\x8b\x87\x39\xcd\xe6\x4f\xe0\x0f\x6b\x14\xb7\xd9\xf7\x3f\x16\x3f\x2e\x63\x94\x7c\xdd\xfe\x59\xcb\x36\x1a\x97\xec\xd3\xcf\x37\x3f\xac\xe9\xaf\x52\x7e\x00\xfe\xed\x5f\x3e\x58\xc3\x36\x27\xff\x78\x51\x4a\x34\x1e\x81\xcf\xf3\x8a\x7e\x8c\x87\xaa\xcd\xe6\xb1\x8d\xd6\xec\x37\xeb\xb3\xcc\x09\x90\x2c\x0b\xd0\x45\x55\xff\x6d\xb2\x2c\x1f\xfe\x0d\xf8\xf7\x2e\x4b\xab\xe8\xc3\x38\x57\xfd\xfa\xfd\xbf\x7d\xf3\x29\xca\xd7\x6c\xfe\xe6\x53\x9c\xe5\xc3\x9c\x7d\xff\xe3\xbc\xfd\x2b\x08\x82\xff\x52\x75\xe3\x30\xaf\x51\xbf\x7e\xf7\xe3\xec\x97\x51\x3a\x1c\x9f\xfa\xa1\xcf\xbe\x6a\xfa\x75\xca\x3f\x81\x1f\xbe\xe6\xf9\x79\x4d\xe3\xe1\xfc\x67\xac\xff\xac\xe5\x87\xe8\x9b\xe8\xd3\x5e\x2d\xd5\x9a\xa5\xdf\x7f\xe9\x3b\xcd\x92\x61\x8e\xd6\x6a\xe8\x3f\x6d\x7d\x9a\xcd\x9f\xd7\xed\x87\xe8\xff\x5f\xce\x59\xfe\xff\xfc\x38\x80\xef\x93\xa1\x5f\xb3\x7e\xfd\xf4\xa7\x0f\x7f\xf9\xd3\x87\x68\x5d\xe7\xbf\x7c\x6e\xfd\xeb\x87\x3f\xfd\xf5\x4f\x3f\xac\x9f\x97\xa6\xc8\x3e\xc6\x73\x16\x35\x1f\xab\x7e\xa9\xd2\xec\x53\xb4\x0f\x55\xfa\xc3\xb7\xbf\x59\xa0\xbf\x5b\x8f\xaf\x94\xfa\x91\xf2\xc3\x9a\xfe\xbd\x99\xfd\x6b\x9e\xe7\x5f\x51\xfe\xf0\xef\x3f\xd9\x79\x92\xfd\xc6\xe2\xff\xcc\xb7\xd7\x58\x56\x9f\xdd\xee\x83\x10\xb5\x79\x5b\xf5\xc5\xf2\xe7\xef\x96\x39\xf9\xb4\xcd\xed\x5f\xbe\xfd\x16\xf8\x4c\xbd\x00\xc5\x2f\x64\x1f\xcb\x9f\xc9\x3e\xce\x59\xb1\xb5\xd1\xfc\x6d\x36\xac\x7f\xfd\xef\xb3\xfc\xff\xfe\xb5\xca\xf2\xea\xfc\xeb\x87\x7c\x98\xbb\x68\xfd\xcb\x9f\xb3\x2e\xce\xd2\x34\x4b\x3f\x0e\x63\xd6\xaf\xd7\x98\xfd\xf9\xaf\xdf\xfc\xd7\x25\x1e\x43\x9e\x43\xbf\x0a\xfb\x52\xfc\x6f\x0b\xf8\x2d\xff\x7f\x8b\x7d\x5d\xbf\xe2\x5e\xe7\x2d\xfb\x6f\x8f\x60\xd9\x8b\x7f\xfd\x95\xe0\xff\xfc\x42\xf0\x53\xfb\xaf\xd2\x97\xbd\xf8\xf3\x5f\x7f\xf8\xb7\xef\x7f\x63\xcf\xd5\xfd\xd9\x41\x7f\x32\x9a\x78\x38\xbf\xfb\x02\x05\xff\xb8\xe9\x1f\xd6\xfe\xf0\x1f\xdc\xee\x77\x96\xfe\x2b\xd8\x7e\xc6\xcc\x4f\x4f\x70\x3c\x7f\x05\xd9\x68\xfc\x58\x56\x45\xd9\x7e\xc6\xb9\x9f\x0c\x78\x2e\xe2\xe8\x2f\xe0\x37\x5f\xae\xbf\xfe\x08\xab\x5f\x1b\xee\x9f\x84\xac\xdd\xb3\xb5\x4a\xa2\x0f\xef\x6c\xcb\xfe\xf4\xcd\x2f\xe5\x6f\xc8\xb9\x8a\xda\x6f\xbe\xc2\xf2\xaf\x7a\x45\xc6\xf3\xbb\xcf\x9e\xfa\xb1\xfc\x11\x53\x9f\xdf\x22\xd0\x0b\xc5\x9f\x08\xfc\xdd\x4f\x7e\x03\xc3\xf0\x77\xff\xd0\x9b\x7e\x88\xbe\xff\x85\x04\x8f\x62\xfc\xbb\xff\x08\x03\x9f\x11\xe3\x87\xe8\xd3\x17\xf4\xfd\x05\xd1\x7f\x62\x81\x60\x14\xc2\x93\xbf\x63\xf9\x0a\x39\x7e\xe4\xfb\x25\x02\xac\x65\xd5\x7f\x48\x87\x75\xcd\xd2\xef\x7e\xae\x43\xc7\xf3\x43\xb4\xad\xc3\x87\x9f\xe7\xed\x47\xa0\x9f\xab\xbe\xf8\x51\xcf\x9f\x29\x3f\x0e\x79\xbe\x64\xeb\xa7\x8f\xd0\x78\xfe\xf0\xed\x3c\x1c\x3f\x45\xa4\x8f\xf3\x97\x41\x7f\x7c\xa2\xe3\xf9\xdd\x4f\x55\x6d\x96\xff\x54\xf3\xc3\xb7\xc9\xd0\x7e\x3c\x97\x8f\x4f\xe8\x9b\x9f\x6f\xa1\xef\xc7\x61\xa9\xbe\xe8\x3a\x67\x6d\xf4\x39\x58\x7d\xd7\x55\xfd\x2f\xd3\x37\x9e\xdf\xfd\x14\x1b\x7e\x92\xfd\x45\xf4\xcf\x55\x5f\x64\xff\x73\xd1\x79\x3b\x44\xeb\xa7\xcf\x44\x5f\xb5\x7f\x7f\x54\xe9\x5a\xfe\x18\x4c\x7f\x25\xfd\xa9\x12\xfb\x16\xfb\xf1\x0f\xff\x9f\x3f\x87\xb1\xff\x2c\xbe\xfe\x84\xa4\xbf\x4a\xfc\xae\x8b\xce\x8f\xbf\x29\x7e\x99\x83\x78\x58\xd7\xa1\xfb\x04\x81\x9f\x35\xfd\xc2\xf3\xb7\xf5\xb3\xc5\xfd\x6d\x9d\xff\xf6\x55\xf4\x7b\xfd\x73\xe3\xf9\x9c\x62\x54\x49\xd4\x7e\x8c\xda\xaa\xe8\x3f\xad\xc3\xf8\x73\x3c\x5d\x87\xf1\xf3\x34\x7d\x58\x86\xb6\x4a\x3f\xfc\x6b\x9a\xfe\x0c\xf0\x1f\x97\x75\xae\xc6\x2c\xfd\xa5\xab\x4f\xfd\x5a\x7e\x1c\xf2\x8f\x9f\x81\xe3\x2f\x43\x9a\xfe\xf5\x1f\xa1\x3a\xf1\xf9\xfa\xe1\xdb\xcf\x50\xf0\xf1\x73\x7c\x99\x87\xf6\xa7\xa8\x3f\xb6\x51\x92\x95\x43\x9b\xfe\x6a\x75\x04\x41\x7c\x37\x7c\x0e\xf0\xeb\xf5\xe9\xf9\x1f\x98\x3e\xa7\x30\x5f\x92\x86\x7f\xc2\xf8\xc3\xb7\x63\xd4\x67\xed\xf7\x7f\x3f\x45\xff\xd8\x3d\x7e\xce\x2f\x7e\x1d\xeb\x57\x2b\xf1\xf3\x64\xcc\x51\x5a\x6d\xcb\x27\xe4\x2b\xdf\xff\x2a\xe4\x82\x1f\x3e\x33\x7f\xfe\xff\xca\xf9\xbf\x05\xd1\xbf\x7e\xf7\x5f\x21\xfa\x49\xe1\x8f\x9f\x93\xce\xaa\x2f\x7e\x59\xb5\xcf\x48\xf3\xe1\x8b\x59\xfe\x82\x46\x5f\x86\xf2\x9f\x2a\xba\x0e\xe3\x17\xeb\xfd\x59\x63\xf8\x57\xf6\xcf\x4d\x5f\x6c\xfd\xab\xb6\x9f\xfa\xfe\xdb\x4f\x06\xf7\xdb\x39\x03\x7f\xdb\xfa\xa9\x8d\x96\xf5\x63\x52\x56\x6d\xfa\xfd\x6f\x34\xfa\x3b\xa9\xbf\x55\xf8\x3f\xea\xf3\x4f\xa5\xfe\x68\x50\xbf\xa9\x98\xff\xbf\xee\xf4\xc3\x9a\x7e\xca\xab\xf9\x9f\xe8\xf0\x3b\x76\xf2\x5f\x1e\xe7\x6f\x3b\xf9\x49\xf2\x57\x2a\x7e\x16\xfd\x55\xf1\x4b\x92\xf5\xab\x47\xff\xbc\xa6\x1f\xd3\x2c\x8f\xb6\x76\xfd\x2a\x5b\xfb\xec\x0f\x5f\xbc\xfc\x37\x04\x7f\xfb\x0f\xd6\xf9\x9f\x47\x1b\xf4\xf3\xf5\xdd\x3f\x90\x39\x0f\xc7\x4f\x61\xfa\xcb\xed\x4f\xa1\x3a\xad\x96\xb1\x8d\xae\x4f\x5f\x86\xf2\xdd\xaf\x69\xe7\x9f\xbe\x62\xf8\x3e\x69\xb3\x68\xfe\x14\x0f\x6b\xf9\xc3\xbf\x7f\x76\xfe\xbd\xca\x8e\xcf\xe9\xe1\x4f\xf0\x98\x66\x7b\x95\x64\x3f\x82\xe3\x0f\xdf\x56\x63\xbe\x7c\xfc\x3f\x71\x1b\xf5\xcd\xd7\x28\x54\x75\x51\x91\x7d\x49\xf3\xfe\x9c\x46\x6b\xf4\xe9\x4b\x19\x18\xfb\xe2\xbb\x38\x5a\x32\x0c\xf9\xa6\x72\x29\xcd\x3c\x40\x99\x2f\x06\x92\x24\xc9\xb7\xe5\x94\xac\x53\x90\x24\x49\x7d\x2e\x92\x06\x4d\x06\x9f\x3f\xf3\x17\x40\x94\x9f\x6f\x78\xdf\xe4\x3c\xc1\xb4\x63\x28\x04\x53\x88\xbb\x42\x83\xa2\x42\x9e\xa8\x42\x8b\x92\x62\x8f\xeb\x43\x57\x6a\x03\xcf\x44\x93\xa4\x6d\xf5\xcf\x0c\x1e\x25\x99\x2c\xe7\x64\xef\x89\x75\xea\xa7\x72\xb2\xa4\xd1\xa7\x4f\xd5\x25\x91\xf6\x12\x59\xef\xc4\x1c\x51\x66\x79\x87\x3d\xf9\x25\xa6\xe1\x55\xc9\x0f\x09\x28\x6d\xa0\xc0\xdd\x96\xee\xb7\x78\x3a\x7d\xea\x28\x00\x03\x29\x0d\x1d\x50\x4a\x59\x41\xfb\x70\xa3\x96\x7d\xe3\x73\x0f\x55\xf9\x6b\xbb\x55\xbc\xbe\xd3\xdd\xdd\x4c\x94\x29\x82\x3e\x7c\xe4\x04\x11\x55\xb8\xbb\xa2\x2b\x21\x13\x5b\xbf\x21\x82\x72\x64\x22\x3c\x79\xc1\x29\x62\x3a\x33\x2c\xe9\x05\xe6\x65\xd2\xaf\xa7\x86\x20\x74\xa2\x51\xb7\x4e\xe2\x5d\xce\x5e\x9b\x70\xe4\x78\xbf\x1a\x0d\x52\x27\xfd\x75\x68\xa7\xd8\xe6\xa7\x46\xbf\x83\x48\x71\x8b\x18\x4b\xfc\xb8\xb1\xd3\x52\xf2\x27\xc8\x12\xdb\xb7\x4a\x83\xa7\x38\x95\x42\x72\x33\x71\xf5\xd2\xdc\x7b\x54\x2c\x27\x02\xbd\x2c\x36\xf3\xae\x2a\x14\x61\xaa\x9f\x6c\xa2\x87\xfd\x91\xe3\x45\xcc\x88\x73\xe0\x9a\x17\x5b\xf5\xdb\x5c\x63\xb5\x4d\x09\x97\x88\x8f\x93\x3b\x73\xc6\xc4\xc6\x2b\x66\xb3\x5d\x48\xec\xcf\xb7\x49\x4a\x6f\xfa\x79\xda\xc1\x29\x1a\x25\xa0\x76\xa6\xd3\x76\x9c\xc1\xc2\x93\xa7\x79\xcf\x7e\xa2\x20\xdb\x6b\x9e\x00\xbc\x16\x92\x0b\x1e\x91\xbb\x37\x9c\xc8\x66\x61\x2c\x4c\x08\xdb\x5e\xf2\x4d\x76\xac\xaf\x9d\x58\xd1\xb3\xae\xb4\x79\xd4\xdd\x35\xa6\x44\x99\x7a\xc0\x87\x14\xb3\xb8\x91\xd6\x8e\x56\xe1\x4a\x2c\x74\xb9\x11\x99\x01\x60\x73\x02\x70\x74\x53\xa6\x06\xba\x4b\xac\x72\x21\x0b\xd3\x8c\x15\xca\x47\x16\xe6\x81\xe8\x16\x0f\x26\xc4\x76\xbc\x24\x78\xc6\xd5\x8e\x50\x3f\x00\x7d\x38\xe5\x0d\xc8\xc9\xe2\x20\x95\x98\x21\xfd\x1c\x67\x52\xa3\xf9\x62\x28\x96\xe3\x6a\xa6\x8c\xd2\x81\x28\xfe\xef\x3f\xff\xf5\x6b\x17\x99\xb3\x31\x8b\xd6\x4f\xfd\xf0\xd3\xdd\xd7\x6d\x5f\x72\xbc\xcf\xe6\x1f\x55\xfd\xcf\x36\xfc\x79\x97\xf5\xc7\x32\xe1\xae\xfc\xc9\x84\xc7\xc5\xb9\xd7\x1d\x7c\x92\x81\x9e\xa7\xa5\x76\x01\xbe\x1d\xbe\x40\xd7\x7d\xba\x03\x3d\xb5\x24\x74\x1b\x93\x53\x1c\x2a\xcb\xce\x1e\x45\x2a\x3b\xc2\x4b\x4c\xce\x32\x9d\xc6\x0a\x0b\x67\x4f\x2e\x6d\xb3\x27\x59\x55\x96\x08\x19\xac\x2c\xc9\xac\xe5\x72\x1c\xe5\x0d\x20\x62\xb3\x96\x79\xe7\x17\x94\xe0\x4a\x00\x34\xca\x9a\x43\xe9\xeb\x81\xa2\xe8\xbd\xab\xc4\x3b\x12\x9f\xc3\x1c\xa1\xcb\x1e\x5f\x84\xd6\xc7\x0e\x4b\x9d\x05\xd3\x8a\x72\xe5\xd5\xbe\x91\x29\xd7\x93\x00\xfc\x27\xbe\xb0\x6b\xa2\x07\xd0\xbc\x0a\x16\x81\x01\xc2\x06\x9a\xbb\xef\x2b\xf7\x23\x71\x6e\xf5\x85\xdf\x56\xb9\x88\x10\xc1\x8c\x02\x1d\xac\x08\x8b\x51\xc3\x89\x88\xe1\x6d\xf7\x31\x73\xe2\x2e\x8e\xf0\x75\xa9\x59\xf9\x51\xb0\xa0\x00\x61\xf0\x4b\x26\x4a\xf0\x45\xc2\x95\xc0\xbb\x71\x6d\x1f\x78\x81\x05\x1d\x79\x1d\x00\x55\x64\x89\xf0\xe6\x79\xa9\xde\x73\xa3\x14\xf3\x2e\x17\x39\x86\xf4\xa5\xb1\xde\xb6\xa2\xc2\xd3\x5a\xe4\x5c\x11\xd1\xc1\xb1\x4d\xd6\x42\x32\xc0\xb3\xe7\x32\x34\xd3\x34\x10\xd2\x0e\x76\x84\xdc\xa6\xb4\xe8\x9e\x7e\x79\x1a\x9d\x4e\xc5\xd1\xdf\xdc\x89\x00\xe2\x35\x8e\x87\xe9\xbe\x1f\x7e\xe0\x2f\x59\x32\x85\xe4\x73\xa4\x90\x57\xd6\x90\xfd\x41\x00\x08\x1f\x9e\xb0\x02\x22\x6f\x80\x1f\xec\x83\xad\x7d\x24\x79\x0b\xe8\xde\xea\x79\xbd\x92\x62\x30\xbe\x12\x6f\x36\xb6\xf5\x9c\x69\x54\x1d\x52\xd8\x5d\x7c\xd7\x56\x39\x6b\x5a\x23\xf6\x51\xb4\x44\x5a\x46\xce\xc9\x42\xab\x1f\x56\x1c\xde\x07\x55\x15\xad\x12\xbc\xa3\xcb\xcb\x04\x9e\x97\x46\xbf\x15\x6d\x3b\xea\x86\x55\x2a\x3b\xee\x68\x22\x95\x84\x51\x8c\x78\xd2\x5a\x98\x66\xe0\x0c\x5e\x32\x0e\xc1\x53\x13\xc1\x93\x02\xad\x73\xea\xa7\x56\xef\xc6\xb0\x6e\xd7\xba\xa2\xbd\xa0\x2a\x2c\xdf\xd0\xd7\x89\x19\x0e\xfc\x42\xea\xa3\x71\xc8\x14\x5a\x4e\x29\xb6\x00\xc3\x2a\xc3\xb5\x00\x5e\xb3\x70\xdf\x86\x76\x5b\x11\x57\x9e\xc6\x4c\x62\x41\x61\xa8\x86\x30\xd4\xb4\xd3\x16\x3d\x4d\x92\xbb\xcc\x51\x83\xef\x47\x42\x4e\xce\x16\x1d\x32\x2c\x58\x5c\x9e\x54\x70\xa2\xdc\xed\x0e\x27\x6b\x88\xea\xbc\xc5\x06\x8a\x90\x47\xa9\x31\x2b\xe3\xb8\x9b\x04\x48\x38\x0c\x91\xb2\x85\x85\xab\xd8\xa5\xf6\x45\x1a\x06\x05\xc7\xe1\xfb\xd5\x12\x2b\x8e\x8a\x5c\x09\x4a\xaa\x93\xba\xf2\x32\x94\x8b\xa3\x4f\x66\xd1\x37\x11\xb8\x06\x45\x51\x04\x23\x2d\x34\x32\x6f\x2f\x82\x88\xbe\x35\x75\xa8\x29\xa4\xb2\x45\x9a\xce\xc6\xdd\x47\x61\x52\x64\x73\x63\x8d\x9e\x95\x43\x77\x83\x5d\x51\x5d\xca\xce\x15\x64\x16\x69\x2a\x73\xe5\x26\x0d\x53\x0c\x44\x39\x70\x1d\x40\x0a\xdf\xf6\x5b\xc5\x9c\x26\xd2\xf2\x6a\xc1\xa0\xc8\x29\xd2\x94\x8c\xfb\xfb\x31\xfb\x9b\x1e\x3c\xdc\xfe\xae\x57\x02\xa0\x6f\x92\x8c\x3b\xa5\xa6\xe7\x9c\xaa\xcc\xe2\xf7\x85\x88\x28\x4a\xfe\x58\x00\xd1\xff\x02\x10\xa0\xd3\x3c\x75\x16\x64\x83\x7c\x9d\x37\xb7\xdd\x49\xa7\x29\x5d\x56\x1f\xa8\x64\x61\x07\xc5\x94\xa8\x00\x7c\xaa\xba\x50\xd3\x0b\x9c\xec\x43\x91\xd8\x00\x32\x49\xd2\x1b\x7d\xef\x42\x39\x0c\x65\xa2\xf5\xfa\x81\x04\x2c\x2f\x36\x74\xf9\x18\x14\x9e\x92\x3b\x38\xc4\xfb\x10\x4e\xbb\x0c\xda\x6b\xad\xb4\x93\xba\x92\xa4\x3d\xbc\xf5\x5d\x53\x5f\x80\xc0\x43\x13\x0c\xa1\xcc\x0c\x37\xca\x88\x07\xcf\x2a\x1e\xc5\xb3\x5e\x10\xb9\x34\xa8\x30\xdf\x5d\x6c\xc1\x65\xd4\x8d\xc1\xb8\xce\x86\x1c\x0d\xdb\x84\xbf\x16\xfd\x19\xa1\xcf\xae\xca\x35\xe6\x8a\xf7\x9b\x7d\x75\x37\x1d\xcf\xe4\x60\x33\xa2\x5d\xaa\x03\xef\x87\x55\x88\x04\x56\xb5\xcd\xf9\x23\x7c\xfa\xd9\x46\x4f\x12\xae\xd5\x8f\x45\x86\x6b\x23\x79\x93\x5d\xf1\x3a\x1b\xde\xc0\x9f\x5d\x90\xd5\x09\x49\x21\xc4\x3e\x76\xd9\x76\x4b\x49\xd2\x82\x8f\xd4\xa9\x31\x59\x24\xf7\x5c\xa0\xf5\x02\x7e\x3f\x36\x72\x47\xf6\x82\xa0\xb4\x33\xa1\xbb\x9c\xbd\x37\x1d\x28\xb2\x7e\xec\xb2\xa9\x64\xd5\x62\x4b\xb3\x27\x28\x1d\xdd\x83\xd9\x1c\xf1\x72\x52\xbb\x9d\x36\x28\xbe\x06\x35\xf7\x81\xd4\xcc\xe6\x8e\xca\xd8\x53\x58\xec\xca\x7b\x57\xf0\xa3\x55\xc7\xdb\x3c\x98\xa6\x7a\xdd\x27\x2d\x92\x76\x77\xc7\xd9\x9e\x77\x74\xbb\x35\x95\x8e\xbe\xb9\x52\x2a\x8e\xa6\xce\x4c\x3b\x53\xac\x32\xd5\x06\x57\x9a\x7a\xb2\x38\x9a\x82\x26\x43\xec\xe1\xa4\x0a\x4d\xac\x47\x6d\x84\xaf\x31\xbd\xab\x81\x6b\x42\x4a\x08\xe0\x09\xa3\xe0\x16\x49\x25\x96\x65\x75\x8d\xce\x18\x24\x09\x5c\x01\xf7\x97\xfc\x89\x72\x0f\x4e\xec\x68\x1c\x47\xc5\x37\x29\x51\x92\xd5\xb8\x83\x37\x80\x46\x40\x04\x53\x51\x99\x48\x18\xde\x66\xc4\x53\x4d\x7a\xc8\x70\xcc\x9d\xbc\x62\x86\x4e\x4e\xc1\x66\x07\x9d\xc8\x49\xd0\xfc\xba\x38\xa7\x40\x18\x41\x23\x8b\x34\xc3\x6d\xca\x29\x93\xc3\xcd\x87\x47\x6a\x4f\x94\xb9\x40\x5c\xac\xb4\x7e\x5c\xe9\x29\x4b\xab\xb4\x10\xa5\x35\x40\x46\x8c\x1f\xbe\xb9\x29\x4b\x69\x71\xef\xcd\xc4\x42\x9c\xd1\x1c\xf0\x47\x49\xa3\xb7\xd3\x1d\x2f\x6d\xcc\x88\xc3\xe1\xaa\x7e\x1f\xbb\x10\x7f\xcb\x2b\x64\xda\x1d\x85\x94\x72\x38\x60\xfd\x6b\xd2\x11\x6d\x7a\x0a\x54\x23\xb7\x6e\x40\x1a\xd4\xec\xb4\x77\x45\x81\xbe\x61\x55\x39\x12\x74\x46\xd9\x2c\xc5\x5b\x94\x1a\xa2\x8a\x94\x52\x8f\x5c\x22\x06\x9c\xee\xb1\x49\x16\x9d\xde\x17\x13\xf3\xa1\x61\x5a\xcd\x5e\x0f\x8f\x1e\x91\xde\xe7\x16\xf3\x8e\xb5\xd0\xf5\x23\xa4\x47\x8d\x09\xea\x86\x57\xc9\x37\x03\x35\x78\x76\x3a\x4b\x5e\x36\x74\xfa\x80\x88\xab\xd8\xa8\xd7\xcb\x6b\x71\xce\x03\x06\x6c\xb5\x71\xa0\x48\xfc\x89\x2c\xf8\x1d\x2f\xcb\xf3\xa9\x78\x54\x35\x67\x82\xdb\xe3\x44\xa0\x63\x74\x69\xc0\x7d\x1d\x03\x19\xd7\xe6\xde\xc4\x4f\x36\x2c\xc0\x61\xcb\x8b\x25\x2f\x42\x15\xe4\x68\x80\x03\x1c\xcd\x41\x92\xdd\x10\xb5\xc9\xd9\xbe\xc9\xe7\x17\xef\x64\x5b\xce\x6e\xac\xcd\xe8\x68\xfa\xff\x0e\x34\xaa\x3f\x16\x66\x34\xe8\xaf\x49\x05\xf8\xdc\xd9\x96\x75\x74\x5b\xbf\xc3\x89\x22\x8d\xc8\xe2\x8c\x4a\x0a\x9c\xae\x95\x83\x72\xb0\x39\xe4\xa9\xc0\x76\xbc\x01\x06\xf0\x20\xf7\xc5\x87\xa9\x11\x28\xf4\x65\xf3\x94\x79\xba\x26\x03\xb7\x9d\x53\x5d\xc9\x9d\x7b\xae\x01\x3f\xf8\xc7\xfb\xc0\x8f\x1d\xbf\x8f\xa0\x58\x65\x1f\x56\x0e\x18\x27\x50\x1c\x1d\xd1\x1b\xc7\x35\xf0\x39\x94\xde\x03\x60\xdc\xf2\x75\xd7\x78\x14\xc8\x65\xde\xf2\x29\x4f\x84\x0b\x7f\x28\xef\x2b\xcd\xf3\xc2\xcd\xe7\x27\x11\x08\xfb\xc2\x46\x8f\x70\x03\xfa\xb3\x4f\x87\x18\xb5\x56\x43\x7e\xa4\xd7\xbd\x87\xf7\x75\x00\x85\xdc\x76\x6a\x8d\x8b\x57\xc1\xa9\x8f\x73\x7f\x27\x51\x3f\x22\xc0\x8a\xa6\xe4\xd0\xf9\x02\x75\x41\x8e\x43\x69\x1a\xa4\x92\x2d\x40\x11\x40\xa2\xc7\x98\xee\x28\xdb\x20\x9c\xa0\xa7\x82\x19\xcc\xef\xa3\xa3\x9d\x0c\x7c\x84\xa4\xe4\x6d\x6b\x38\x05\x4e\xd0\x4d\xa3\x55\xa0\x9a\x5a\x08\x70\x60\x68\xb1\x82\x12\x1e\x08\x6c\x6d\x3b\xce\x97\x09\x0b\x59\xd1\xc8\xec\x54\x79\x94\xc5\xbb\x88\x09\xef\x06\xbe\x88\xa5\x95\xd8\x21\x67\x8f\xc2\x09\x93\xd0\x13\xa5\xd0\xa5\xdd\xdc\x00\xf0\x3c\xb5\xc0\x1f\xa4\x4d\x01\x6d\xa2\x2c\xf2\x68\x0f\xbd\x70\x33\x0f\x4d\xe5\xd8\xcd\xbe\x5f\x55\xd3\xac\x84\x7c\xac\x44\x20\x85\x14\xfc\x4a\x46\x2a\x1d\x0c\x32\x94\x52\x65\xa7\x79\xea\xca\x07\x9d\xc2\xfc\xb4\x21\xc0\x31\xb8\x30\xbf\x80\x13\x80\x89\xbc\x83\x9c\x0b\x90\x60\x22\x1e\x6d\xe9\xc5\xe1\xde\xe0\x98\x34\x21\x39\xd4\x29\xfd\xea\x90\x68\xa3\xa6\x88\x54\x36\xab\xc8\x6e\xdc\xa5\x9e\xe6\xca\x58\x8e\xa7\x19\xbb\x13\x51\x0a\xe7\xdc\x12\xa5\x4a\x10\x73\x74\x7a\x91\x3e\xa5\xa3\x03\xbd\xc1\x2a\xa4\xbc\x66\xf6\xd9\x96\xcf\xf5\x20\xc5\x8b\x6d\x48\xcd\x40\x4b\x07\x00\xc2\xb4\x40\xb7\xe1\x60\x5a\xe7\xad\xf6\x47\xa8\x78\xe0\x62\x6d\xce\x46\xd2\x41\x79\x18\xe6\xc1\xed\xd2\xb9\x8d\x74\xcd\x06\x8e\x93\x24\x5a\x33\x44\x72\x97\x6a\x6d\xd8\x07\x4f\xbb\x29\xc8\xc4\x27\xcb\xb3\xd4\x0e\x65\x61\x16\x61\x78\xc3\x1b\xa2\xa1\x92\xcd\xe4\x2e\x2d\x60\x22\xd1\xe7\xb5\x98\xc2\x85\x58\x58\x0e\x69\x73\x52\x03\x94\x6e\xb6\xf3\xab\xa6\x1e\x16\xe8\x1f\x06\x4c\xde\x14\xc0\xcd\xad\x5c\xbc\x0c\x08\x17\xa1\x3a\xda\xdd\x21\x9c\xb9\xe2\x60\x90\xc9\xad\x46\x92\xbd\xd4\xb6\x8f\x38\x72\xbe\xa3\x1a\x60\x40\xa6\x52\xfd\x56\x22\x39\xe3\x92\xa1\xf9\x95\xf7\xaa\x6a\x86\x23\xd2\x1a\x4f\x35\xb2\x14\x74\x75\x80\x67\x33\x91\x8d\x4a\x97\xd0\x1a\x88\x0f\xfc\xd1\x94\x38\x98\xd4\x7a\x3c\x23\x31\x1b\xa2\xcf\x3a\x9c\x5f\xb6\xd4\x53\x84\x2e\xf9\xe3\x0d\xbb\x08\x49\x91\xba\x66\xb8\x52\x0f\x19\x18\xc8\xff\xce\xbe\x9f\xe7\x7f\x2c\xef\x1f\x7e\xc9\x18\x1a\x87\x58\x27\xf6\xc9\x3a\x7e\xd8\x85\x23\x0b\x47\x36\xa5\xc4\x12\xa7\xdb\x2b\xe7\x98\xab\x45\xaf\xe5\x8c\x3b\xf4\x25\xcb\x9c\x04\x10\x64\x0f\x0f\x05\x46\x16\xc0\xe0\xe7\x83\x53\xe3\x43\x41\x44\x0b\x4d\x05\xb2\x8d\x39\xa2\x2e\x44\xde\x3a\x4e\xf8\xdb\x81\xa2\x50\x46\x6f\xf4\x08\x89\xf3\x54\x47\xf5\x08\x99\x2d\x3b\x6e\x62\x9c\x67\x18\x0a\x2b\x0d\xc0\xe9\x77\xc4\x9c\xb0\xa6\xac\x58\xae\xd5\xd4\xc4\x17\x40\x24\x9b\xb4\x28\xf6\xe3\xeb\x21\xdf\xb9\x2c\xe0\xf9\x96\xf6\x2e\x87\xbe\x7a\xf6\x89\x65\xed\x03\xb8\x1c\xa8\xa3\x38\xcb\x0b\xe5\xd1\x93\x64\x37\x01\xb5\xc2\xa1\x06\x10\x92\x91\x37\xd3\x39\xd8\x80\xa3\xea\xf9\xf0\xd2\x8d\x10\x1d\x9f\xcb\x2a\x8d\x04\xc6\xfe\x79\x0a\x59\x10\x6d\x85\xcb\xa4\xf7\x18\x8f\xc4\x73\xe2\x5b\x52\xe6\xed\xf3\x95\xd2\x4f\x02\xf0\xc6\xb3\xac\xfb\xe5\xac\x01\xd3\x3c\x9a\x17\x5a\xf2\x12\x4d\xa4\x4f\x0d\xcb\xfb\xcc\x23\xb7\xe1\x5e\x99\xc0\xb2\x94\x8c\xd0\x6c\xcc\xda\x7c\x0a\x4a\x92\x13\x87\x43\x62\xdb\x9a\x83\x39\xf2\x76\x79\x16\xe0\x19\x8a\x01\x40\xa6\x00\xdf\x5f\x2b\xe0\xbb\x79\x7c\x05\xb3\xc5\x98\xec\x4b\x67\x4f\x81\xc2\x80\x17\x85\x19\x5b\x74\x8a\x87\x49\x71\xea\x0a\x56\x22\x59\xa9\xe7\x43\xa1\xaf\xe5\x55\xe7\xbc\xc4\x3a\x55\x03\x79\x63\xa8\x31\x90\x65\xe4\xc4\xc0\xac\xee\x64\x1c\xc3\x48\x93\x55\x80\x61\x9c\x05\x0c\x1d\x1c\xe3\x28\xed\x5a\x90\xda\x3a\x38\x29\x41\x5e\x25\x51\x74\x58\x87\x50\x2a\x6d\x66\xc3\x48\x21\x77\x70\xa4\x89\x3b\x34\x55\x47\x70\xfe\xce\xcf\x00\x0a\xd8\x81\x5e\x4d\xba\x26\xb2\x0e\xb6\xc7\x74\xc1\xb8\x51\x5a\x32\x9e\xa6\x4e\x0b\xe4\x8b\x80\xa7\xee\xe9\xc0\xa0\xf1\x85\x14\x7d\xd0\x93\x22\x44\x5b\xb1\x15\xeb\x25\x3b\x72\x64\xc4\x42\xb7\xc6\x44\x0e\xd9\x7a\xde\xc1\x0c\x16\xca\x94\x19\x3f\xc5\xde\xe8\xb2\x00\x48\x77\x13\x1d\x10\x53\xc3\x5e\xe2\x9b\x4a\xb2\x18\xda\x48\xc6\x7c\x1b\xaf\xd8\xf2\x48\xd7\xbd\x45\x4e\x1e\x3a\xda\xa8\xba\x07\xd8\x6e\x16\x72\xc9\x41\xbb\x08\xad\x79\x85\x03\xce\x2e\x16\x4b\x43\xb0\x8c\xee\xe4\xe2\x97\x80\x40\x40\x77\xd8\x6c\xe6\x7e\x66\x94\x85\xf6\xec\x09\x5d\x23\x24\x4f\xe5\xa9\x0f\x2e\x6a\x07\x16\xf0\xa2\xd7\x94\x1c\xaf\x56\x25\x96\xd0\x90\x65\xcb\xb8\xaf\xcc\xb4\x97\xcc\x74\x21\x63\x20\x6f\x31\x08\x5e\x75\x97\xa1\xcc\x9b\xc8\x45\x30\x35\x06\x47\xac\xc9\x37\x7f\xa5\x3a\xe1\xaa\xb8\x1e\x1e\xc4\x08\x90\x15\x35\xbe\x83\x39\x8d\x0f\x60\x05\x2f\x5b\x9a\xcc\x35\x75\x08\x67\xce\x25\xda\x51\x47\x4b\x12\x8b\xd8\xbb\x97\x20\x43\x9f\x54\xe2\x56\xc2\xad\x08\xd9\x44\x9b\x53\x19\x3e\x03\xff\xb9\x72\xc7\x3b\x0f\xa9\xd3\x22\x34\xf8\xed\x35\x64\x22\x4c\x26\x06\x62\x0d\xd0\x03\x70\x32\xc8\xe4\xe0\x02\x01\xbe\x1b\x80\x16\xd0\x61\xb6\xb7\x73\xb7\xc3\x09\xc8\x2f\x5c\x09\x62\x1b\x0c\xe4\x88\xac\x92\xd4\x6e\x79\x39\x23\x74\xb1\x0c\x7d\xd9\x7d\x50\x92\xe9\xa0\xec\xdc\x48\x45\x51\xfc\xef\xff\xcb\xed\xc7\xfe\x07\x4b\x25\xba\xe7\xaf\xa9\xc4\x6b\xdd\x40\x90\x74\x74\x3f\x4c\xde\x60\x7f\xdb\xe3\x04\xc9\x06\x3c\x92\x47\x23\x92\xbd\x27\x4c\xf4\x90\x65\x27\x15\x3f\x48\xe3\x41\x52\xe1\x8b\x84\x96\x07\x29\x36\x69\x07\x61\x98\xe1\x48\x22\xe7\xc9\x54\x23\x14\x4f\x79\x34\x85\x0a\x1d\x3a\x89\x6f\x62\x09\x8e\x79\xa1\x7e\x20\xea\x93\x35\x66\x7b\xb7\x2e\x5e\xd7\xb7\x2c\xcb\x92\xc7\xe3\xc9\x16\x06\x75\x0a\xe3\x03\x20\xba\xf8\xda\xe6\xca\x0c\xd3\xb3\x96\xa2\x4a\xa6\x18\xd8\x7b\x6c\xcf\xc7\x48\x44\x2f\x14\xeb\xa2\xf3\x51\x30\xda\x2b\x8b\xed\x87\x67\x43\x20\x7b\x57\xc4\x3b\xac\x80\x64\x9e\xa2\x74\xef\x21\xd5\xa0\x48\x3e\x1f\x69\x6d\x9c\xde\xf3\x06\x11\x30\xbe\x9f\xba\x38\x06\x98\xd6\xd7\x49\x72\xc2\xf6\x91\x34\x84\x4a\x55\x96\x03\xf6\x49\x2e\x54\xb3\xcf\x75\xa1\x0f\xab\x29\x71\x4c\xb4\x73\x54\xac\xfb\x06\xee\xc8\xc8\x85\x15\xdc\xf3\x98\xca\xd0\xcd\xb8\x36\xdd\x2d\xc6\x16\x0d\xfb\xe7\xf3\x8a\x15\x04\xa8\x80\xb6\x11\x69\xed\x40\xfb\xca\x30\x79\xc3\x2a\x87\x6a\x12\x31\x6a\x40\x60\x0f\xda\xe2\x57\x0f\x97\xe6\xaa\x84\x36\x5e\xd8\x57\xdf\x60\x45\x43\xfb\x44\x41\x6a\xe7\x48\xf6\x67\x29\x84\xcc\x41\x3f\x81\x48\x7c\xb2\x6e\x25\x0d\xed\x06\x18\xa5\x6c\xaa\x42\xf8\x74\x7c\x90\x9f\x9f\x8e\x25\xb2\x3d\xca\xe9\x9e\x70\x3d\x80\xc3\x1e\x9a\x66\x36\xb4\x09\xda\xa9\x48\x08\xa9\x37\x52\x76\x01\x21\x1d\xf9\x8c\x90\x3d\xb0\x66\x15\x4b\x21\x68\x18\x32\x07\x53\xa9\xe5\xc0\x9e\x36\xf8\x7e\x2c\x01\x43\x6f\x4e\xd3\x8c\xad\x22\xb6\xbe\x8e\x00\x3e\xeb\xa7\xc3\xc3\x74\xca\xb4\xa4\x2c\x2b\x77\x8e\xd5\xb5\x1d\xfe\xa5\x8a\x82\x4c\x18\xee\x24\xe2\x0c\xb0\x05\xd8\x3e\x43\xe3\xd1\xd1\xfa\xdc\xdc\x0f\xbb\x21\x8a\x83\x34\x3d\x83\xf0\xce\x71\x8c\xfd\xb0\x7c\xf7\xe3\xf1\xb8\x22\x84\x44\x85\xb0\xc2\x14\xa4\x15\xcd\x97\x77\xd1\x89\x82\x2d\x76\x58\x91\x5e\xed\x15\x64\x37\x9e\x4d\x8f\x3e\x9a\xc9\x8e\x3a\x19\xf3\x1a\xfa\xe8\x58\xb3\x53\x18\x65\xaf\x29\x50\x55\x88\xaa\xf1\x7c\x5d\xe1\xb6\xe1\x0e\xb4\x68\x84\x95\x97\x10\xbc\x31\x46\x48\x63\x0b\x48\x51\x3a\xb3\x5d\xaa\x4f\xa9\xfb\x85\x73\x34\xa5\x04\xcd\xdb\xbe\xc4\x9a\x32\xb2\xae\x17\xd9\xc5\x0a\xd0\x36\x98\xe5\xe7\xc3\x19\xbc\xc4\x1e\x14\xb5\x66\x05\xf2\x12\x0d\x88\xa2\x29\xeb\x04\xde\x6e\xf9\x08\x9d\x72\x9e\x3a\x76\xa2\xb2\xd8\x82\xbd\xab\x4c\x95\x02\xbc\x57\x60\x2b\xc8\x48\x6c\xda\xc5\xe2\x15\x81\x56\x22\xec\x66\x54\xbe\x0c\x21\xa1\xbe\xf8\xa5\x1f\x39\x7d\x7a\x0b\x7d\x00\xe5\x9d\xb0\xc3\x26\x6a\xa9\x57\x17\xc4\xa6\xb6\xdc\x96\x01\x99\x1a\x19\x10\x93\x50\x0d\xf9\xde\x9e\x56\x82\x9e\x8b\x2c\x4f\x53\x1f\xc0\x69\x65\xb2\x44\x89\xf8\x68\x0a\x8c\x77\x81\xb7\xbd\x8a\x54\xfb\x32\x1f\x24\x93\x11\x5e\x01\xd0\x86\x54\x70\xe4\xef\x0c\x14\x71\x37\xfe\xc1\x80\x22\xfc\xf5\x39\xc5\xe3\x39\x3b\x2d\x1b\x00\x4f\x78\x27\x02\x17\xdc\x27\xe8\x58\x57\x11\xa5\xd3\x51\x21\x22\x96\xa7\x42\x87\xd9\xc1\x34\xc7\xb0\x97\x88\xf5\x8f\x61\x06\x1d\x03\x30\xb7\x8d\x01\xd9\xc2\x65\xc8\x70\x5e\x64\x0e\x21\xcd\x67\x84\xd1\x9a\xec\xa1\x93\xbf\xfb\x59\x02\xe1\xfa\xe6\x66\x69\x04\xc7\x45\xc2\x61\xd9\x0b\xb8\x32\x14\x48\xf1\xbe\x52\xc3\xb2\x60\xcf\x5e\x26\xf2\xd8\x9e\x3b\x74\x8c\x29\x5e\x0d\x99\xa6\xa0\xaf\xe9\xe1\x5e\xa5\xed\x44\x36\xc6\x0e\x50\x28\x48\x99\xae\x7b\xbe\xe4\x9b\x65\x76\xc3\xd4\xf3\x3a\x3b\x15\x30\xd2\x64\xf5\x1d\x8b\x2e\x56\x17\xd1\x2f\x84\xde\x03\x38\x69\x2e\x24\x7b\x9e\x28\xd3\x2a\x74\xc4\xc7\xf1\x5d\xfb\x4c\x32\x6c\x0b\x8f\x6a\x46\x86\x0a\xba\x69\xd1\x86\x2e\x23\xfa\xb8\xb0\x2a\xe0\x0b\x88\xb7\x97\x16\xd2\x0f\xd9\x06\x4b\x87\xc0\xf3\x66\xe5\x28\xe5\xa2\x0e\x72\x68\x21\x22\xc8\xaf\xac\x48\x11\x5d\xe1\x28\x12\x4f\x82\x0f\x82\xd1\xa9\x91\xb2\xf1\x25\xcf\xf7\xfc\xe9\x01\x4a\x81\x69\x85\xb4\xe5\xc7\x8b\x06\x69\x93\x67\x7d\x2f\xba\x9d\xa3\xaa\x2e\xce\xa8\xc9\x57\xbc\xd4\xae\x5c\x47\xd2\x3d\xec\x2a\x03\x18\x68\x71\x5e\x52\xc9\x43\xc9\x7e\x65\x7e\x06\x25\xe4\x46\x32\xc6\x9b\xa7\x3a\x6a\x57\x22\x7e\xb3\x39\x33\x62\xf2\x12\x7e\xb6\x94\xed\x55\xc4\xb8\x75\x75\x2c\x83\x14\x22\x19\x5b\x0b\xef\x9a\x31\xaa\x2f\x29\x5d\x1a\x4d\x99\x53\x7a\x67\x12\xa6\x26\x97\x7a\x2d\x50\x5b\x6c\x86\x4a\x56\xa2\xa1\x51\xdf\x26\x94\xf4\x61\x3c\xbd\x49\xf5\x4a\x26\x1e\xf7\x63\x41\x36\xa1\x5c\xbd\x0f\x0d\x48\x97\xd3\x3a\x36\x90\xaa\x28\x69\x79\x2f\x3b\xa4\x1c\xa4\x44\x4a\xb4\x88\x6e\x27\x54\xf8\x41\x3c\xbd\xb3\x35\xb9\x51\x7d\xd0\x4c\xf1\x99\x30\x16\xd8\xbf\xc8\x93\xf7\x70\xf2\x71\xef\x6c\x40\xc9\x21\x14\xb6\xc9\xc2\xae\x92\x12\x67\xa9\x5a\x67\x3a\x15\xd1\xb6\xa1\x16\xe5\x89\xa0\x5b\x7b\x79\xcd\x7d\xaa\xae\x63\x40\xa6\x6a\x94\x4a\xce\x69\x4f\x2c\x20\x27\x7a\xae\x4e\xbd\xef\xb0\x6a\x92\x67\x33\x86\x3c\x08\x66\x73\x0e\x49\x9c\xb7\x35\x0b\x05\x01\x26\x33\x5e\x32\x17\x05\xc3\xaa\xdd\x5b\x9d\x23\x93\x8a\xbb\x20\x9b\xd8\x9a\x5a\x7d\x16\x0f\x72\xd1\x4b\xde\x6d\xe1\x7c\x13\x5b\x68\x15\x35\x0a\x0c\x22\xe2\x59\x34\x5a\x45\x74\x67\x49\x46\x2d\x98\x35\xc3\xdc\x3c\xab\x04\x68\x78\x85\xd2\x4c\xf5\xbc\x20\xf9\x39\x59\x84\xfb\x0c\x8d\xf8\x6d\x97\x62\x0d\xb1\x7c\xf9\x80\xd6\xe5\xd2\x7a\x2b\xaa\x5e\xf3\xd3\x39\xd5\xb7\x48\x51\x0f\xc5\xb4\x6d\x47\x99\x11\x27\x5d\x40\xf9\xb9\x3a\xc0\xa6\x29\xa7\x38\x77\xf1\xfb\x7e\xf9\xbe\x35\xf7\xa4\x65\x8d\x5b\xcc\x13\x79\x2c\x9b\x97\x5b\x3e\x7b\xe0\xb6\x0e\x88\x58\x89\x81\x7e\xc6\x08\xae\xe6\x87\x13\x90\xa4\xb3\x28\x95\x37\x23\x86\x23\xfd\xae\x7b\x92\x3f\xd8\x23\xcc\xe4\xfc\xf5\x98\xae\x79\xce\x5f\x1e\x61\x76\x61\xdf\x14\x83\x44\x47\xfc\x9b\xce\xca\x4d\xb2\xa3\xb6\x94\x42\xcb\x09\x29\x0c\x8b\x40\xe1\xf0\x17\x1d\x30\xfa\x07\xa7\x3e\x88\x47\xb9\x5e\xa0\xf2\x0e\xe8\x19\x12\x71\xc7\x55\x44\x0f\xe4\x12\xb0\x1c\x8d\xd1\xb2\x70\x0d\x57\x67\x8d\x50\x97\x71\xdb\x5d\xf7\x15\xa8\x7d\x03\xf4\x3d\x94\xa1\x27\xe8\x99\x26\xa7\xee\x3a\x70\x60\x9e\x75\xa3\x75\x5c\x01\xc4\xfb\xcc\x75\x8c\x80\xbd\x11\x66\x66\x89\xee\x55\x0f\x4d\xa1\x97\x8e\x47\x0f\x91\x7d\xa2\xed\x96\x9b\xaf\xe1\x19\xb2\xd6\x7a\xe8\x65\xe3\x09\x8b\x17\xcf\xe1\x23\x7b\xb3\xfa\xb9\x6c\x5b\xcc\x72\x58\x07\xda\xd4\x0e\x19\x48\x5b\xe9\x43\xee\x6f\xf7\x9e\x6d\xed\xba\x5a\x93\x07\x39\x87\xf0\xe0\xeb\x89\x06\xcb\x61\x1e\x2d\x05\xea\x6b\xe7\x45\x3c\xb8\x4b\x3d\xea\xd6\x6e\x4f\x4d\x52\xed\x88\x08\x0d\xe1\x66\x0c\xb1\x2e\x8e\x74\xe8\x88\x5b\xb9\x73\x5f\x4f\x70\xb4\x89\x7b\x8d\x5c\x0e\x4a\xb2\x5b\x1a\xf2\xe7\xc9\x30\x55\xe5\x2c\x2b\x04\x81\x98\x82\x42\x1c\x8e\x2a\x0b\x7d\xec\x60\x0a\x1d\x0b\x4a\x78\x3b\xce\x69\xc8\xa4\xb0\xbc\x46\x21\x87\x6d\x76\xe3\xd4\x6c\x55\x09\x51\x9e\x81\x0a\xea\x3c\xf5\xa0\x41\xab\xdf\x2c\xce\xe6\xa1\x40\xbe\xc6\xf1\x90\x03\x37\xe5\x35\xdc\xe6\xca\x9b\x9a\x78\x31\xeb\xdd\x4c\xa1\x9d\x35\x77\xcc\x82\x9d\xb7\xe4\x44\x59\x5a\x36\x59\x99\x72\x90\x14\xa6\xf0\xe7\x4b\x17\x6e\x2c\x11\x69\xde\x06\x9e\xc6\xf2\x9a\x46\x63\xe5\xb5\xf4\x2a\x57\x9e\x25\x4d\x8f\x31\xb8\xc9\x90\xac\x8c\x51\x88\xd7\x86\xb8\xb1\x12\xc9\x07\x21\x9a\xa4\xa4\x1f\xf5\x3a\x48\x7c\xeb\x92\x03\x63\xbc\x40\xf0\x91\x9b\x9c\x6d\x07\x7e\x52\xb7\x89\xff\x86\x8a\xc7\x63\x81\xb1\x11\x55\xee\xbb\xdd\xb3\x67\xc5\x9a\x5a\xf4\xa2\x78\xe1\xc9\xc6\xb3\x45\x66\xd3\x5c\x9f\xec\x54\x25\x82\xb1\xbe\x80\xc0\x62\x04\x75\x8c\xde\x0b\x7e\x48\xe4\x48\xec\x7b\x1e\x43\x2f\xbc\x4a\xe3\x81\x74\x1b\x93\x8c\xd0\x9c\x0a\x7c\x9d\x98\x4f\x0d\x51\x8b\x1c\x3c\x77\x5d\x4f\x85\x82\x64\xc9\x97\x36\xf0\x29\x02\x56\xcf\x1a\xfc\x7d\xcf\x04\x92\xf1\x0f\x16\x6b\x73\xe9\x57\x87\x5a\x08\x9d\x05\x59\x07\xe8\x42\xc8\x2b\xa6\xd1\xf7\x1f\x86\xc8\x70\x69\xd4\xba\x4b\x5b\xbe\xde\x2d\xa9\x19\x91\x26\x73\xe4\x91\xef\xc2\x7e\xd8\x00\xa7\xbe\x32\xc0\x01\x54\xad\xa7\xba\x23\xa9\x5f\x1e\x03\x92\x34\xcb\x17\xa5\xd8\xc4\x0e\x18\x47\x11\xbb\x96\x19\xac\xd9\x12\x18\x7a\x2e\x84\x4d\x30\x2e\x85\x2b\xf6\xca\x32\x20\x26\x70\x18\xbe\x78\xf2\x28\xd4\x58\x79\x42\x40\x7e\x3f\xa2\x3b\xee\x49\x3d\x80\xde\xf3\x8a\x87\xf9\x74\x13\x92\x3a\x07\xe1\x43\x42\x80\x0c\x1a\x35\xae\xae\x92\xca\xdc\xfd\xb6\x18\x51\xfe\x16\x86\xde\x6f\xa0\x01\xb3\x5e\x2e\xd6\x00\x76\x4d\xcd\x2a\x70\xf2\x24\xa2\x2a\x57\xa6\x59\x7a\xf8\xaa\x9b\x13\x67\x1e\xdb\x44\x3b\x30\xd9\x5d\xcf\x4b\x0c\xaa\x9b\x82\x31\xb2\xa5\xad\xe6\xc8\x6b\x8f\x31\x91\x6d\x43\xc0\x4b\x6d\x81\xe5\xe1\x1f\x75\xe6\xd9\xa5\x61\x20\x21\x66\xbc\xad\xde\x6a\x82\xab\x49\x18\x3f\x5a\x74\xa4\xed\xf2\x5d\x0b\x6d\x8b\x23\xa6\x97\xcd\x50\x2c\xa7\xc7\x6f\x34\xd6\x26\xba\x68\x69\x9a\x3e\x65\xd0\xde\xf7\xf0\x12\x5d\x84\x16\xcf\xb8\x18\xe9\x07\x52\x74\x80\xee\x74\x1c\x2d\xb2\xaf\x4a\xd2\x2f\x95\x05\xb2\x97\x32\xf4\x44\x8d\x08\xfb\x25\x04\x4a\x2d\x5b\x87\x49\x5b\xac\x53\xe4\xc4\xe3\x89\x76\x5c\x7c\xbe\x0c\x0b\xa3\x43\x49\xbd\x25\xc2\x6a\x29\xfa\xf0\xe1\x5c\x62\x14\x1e\xd1\x7d\xfc\x6a\x92\xa3\xe9\x8c\x4e\x5a\x47\xb6\xf4\x22\xbc\x78\xa6\xfb\xbb\xb5\x8e\xfa\xc8\xda\x2c\xbe\xf1\x95\xf4\x95\xa1\x2d\xc1\x11\xe0\xce\x8c\xc8\xd9\x59\x86\x3c\x86\xe3\xd9\x42\xae\xcf\xfc\x5d\x67\x85\x0f\xb6\x8c\x9d\x00\x65\xf6\xde\x38\x82\x00\x04\x9e\x5d\xda\x44\xf6\x8f\x6b\x88\x6e\xef\xcd\xa4\x2d\x3d\x63\x0f\x66\x90\x8a\x99\xba\x53\x11\xb4\x89\x39\xd0\xb0\xab\x80\xee\xe5\x56\xdb\x48\x56\x61\x66\x47\x35\xea\x8e\xb7\x2b\xdc\xee\xee\x49\x3d\x31\x07\x79\xdf\x37\x94\xc3\x09\xa7\x9d\x20\x3f\x3d\x21\x8e\x48\xee\x75\x64\xcf\x3e\x59\xa6\x60\x88\x84\xd1\x12\xe5\xf5\x04\x6f\x29\x75\x45\x6e\x14\x0c\x6c\xbc\x20\xa2\xdb\xde\xcd\x73\xb3\xdf\x2f\x88\x18\x00\xcc\x12\xd8\xbe\x7c\x81\x02\x17\xb1\xd8\xbb\xee\x94\xde\x3b\x1d\xe9\x7a\x2a\x97\xdd\xae\x14\xdc\xbc\x28\xaa\xa0\x32\x36\x33\xec\xca\x33\x97\xe6\xf7\x4e\x78\x93\x65\xf9\x63\x39\x61\xf3\xd5\xce\xb8\x59\x77\xa7\x65\x0d\x60\x43\x99\x81\x56\x5a\xc0\x24\x65\x59\x76\x76\xaf\x13\xcf\x3a\xe8\x57\x63\x4d\x36\x58\xd9\xbf\xbc\x7d\xe2\x2b\xeb\x13\x4b\x06\x8e\x86\xf4\x65\xa8\xd9\x48\x95\xc3\x95\x9e\xb8\xc8\x4e\xf9\xae\x8e\x2d\x90\xe6\x61\xea\x7a\xec\x59\x05\x6b\x1a\x65\xf1\xbe\xe5\xe0\xdb\xfd\xbe\x42\xfc\x75\xc3\xb7\xc9\x61\xbb\x89\x05\xbb\x7f\xdf\xfa\xac\x3a\xf4\x95\x63\xaf\x98\x22\x6e\xed\xe1\xe6\xa3\xa9\xf5\x68\xd9\x68\x69\xae\xeb\x3e\x00\xb5\x02\xd0\xe6\x95\x52\xa5\xf7\xea\xa3\xdd\x1b\xaa\x15\x9e\x07\x67\x59\x61\xdf\x22\xfb\x6a\x2b\x6f\x4c\xef\x43\xc7\x85\x7d\x92\xa6\xad\xee\xf6\x2d\xe5\x1c\x24\xe6\x82\x97\xd7\x3c\xb9\x70\xd1\xa8\x55\x1e\xc7\xf4\x15\xd0\xcc\x7b\xc3\x71\x3a\xcc\xf6\x14\x2e\xf2\x36\xb7\x1d\x2e\x71\x4a\x1d\xcc\x74\xa5\x8a\x2b\xd1\x24\xe6\xda\xa2\xc6\xe2\x20\xf3\x0c\x49\xdd\xc4\xc5\xd2\x72\xcd\x46\x44\x17\xd0\x6e\xb9\x5a\x3e\x50\xe6\x3b\xbb\x62\x76\x4e\xec\x17\xca\x05\x95\x00\xd0\x97\x4e\xe6\x38\x52\x68\x31\x0d\xed\x6a\x79\x2f\x95\x59\xea\xe5\x48\x63\x99\xe1\xa8\x0f\x96\x7c\x8e\xd2\x2d\x2a\x6c\x5f\x9b\xd6\x26\x2d\xf5\x86\xab\xd2\xb4\x38\xb4\x65\x66\x15\xc6\x8c\xf0\xe5\x4f\x49\xca\xb7\x42\x08\xcc\x8a\x1e\xdd\x86\xc7\xd3\xfd\xeb\x81\x05\x1e\x32\x92\x0d\xeb\x81\x56\x7d\x3b\x77\xd4\x7b\x2d\x1d\x01\x4a\x91\x98\x60\xfb\xce\x87\xdd\x66\x2b\xac\x4d\xc4\xe6\xce\x96\x5e\x05\xcc\x97\xd9\xbe\x41\xf1\xcd\x8f\x70\x89\x30\xc2\xc0\x2c\x2c\x1a\x98\xbb\x71\x55\x72\x65\x5a\xea\x5d\x35\x26\xa9\x59\x90\x37\x4c\x43\xe8\x6d\xc8\x53\xc6\xcd\xe3\x6e\x35\x8d\x74\x19\x55\x55\x85\x52\xe4\x77\xae\x35\x4f\x89\x9b\xe5\xc0\x03\xb3\x11\x14\x83\x82\x86\x2d\xa6\x44\xe2\x67\x6b\x4b\xf5\x3b\x67\xdf\xcb\x1c\xdd\x1a\xa9\x92\x07\xf6\x02\x3b\x7d\xf3\x1e\xaf\x96\xeb\x87\xa7\x8e\xf8\x4c\x55\x98\xa5\x56\x1d\x06\x79\x49\x32\x6e\xc7\xcb\xdb\x02\xf4\x88\xc4\x8b\x8a\x14\xc9\x32\xb8\xa1\xcb\x2c\x28\x31\x5f\x5c\xf2\x75\x88\xd9\xaa\xf3\x18\x47\x4e\x65\xfa\x9e\x69\x74\x03\xf3\x87\xed\x5c\x42\x71\xa9\x36\xc3\xd8\x03\xbb\x02\xf9\x6a\x2c\xec\xee\x21\xac\xce\xa3\x5a\x98\xcc\xfb\x01\x76\x6d\xd5\x45\xb3\xed\x37\x7a\x3e\xfa\x7a\xf2\x6e\x8d\x81\x5f\x6b\x92\x2e\xc6\xf9\x32\xfc\x45\x7f\xaf\x02\xd0\xef\xa6\x3f\x51\xd2\x38\xc8\x82\x7a\xf3\xef\xe6\x4d\x81\x5a\xda\x2e\xb8\xf2\xbe\xc8\x40\x1e\x9d\xe9\x99\xae\xcf\x6a\xdb\x29\x3c\x37\x99\x91\x68\x66\x82\x79\x9e\x1a\x77\x34\xe3\xd0\x2c\xfe\xb6\x74\x7e\x14\x7a\x5c\x0f\x26\x83\xfb\x22\x66\x20\xc6\x00\xb2\x38\xc8\xc6\x61\xdf\x91\x11\x99\xe7\x72\xfc\xbe\x11\x38\x8d\xd6\x3f\x96\xf3\xe7\xee\xcf\x11\x58\x75\xc0\xa7\xce\x3e\x59\x47\xcf\x80\x77\x04\x6e\xe3\xda\xb5\xa4\x55\xc0\xea\x50\x85\x05\x4d\xc2\xa5\xf1\xd2\x05\xb2\x8e\xa7\x63\xb1\x08\x1a\x7e\xd0\xfa\xcb\x7b\x7a\xc0\x83\xb2\xcc\xec\x0a\x1c\xfd\x10\x11\x83\x74\x1b\xb2\x70\xd8\x42\x8c\x5d\xb1\x78\x72\x61\x0c\x8d\x2d\x1a\xc3\xf7\x0e\x25\x02\x55\x2f\x91\x6d\x6b\xd1\x23\x23\x5e\x84\x96\xe7\x09\x9f\xc9\x98\x52\xda\xd9\xce\xed\x0f\x4d\x1a\x42\x41\x17\xb4\x7c\xbe\x81\xa5\x7d\x61\xf2\xe8\xe5\xe5\xd9\x2b\x19\xde\xfa\xca\x13\x18\xde\x80\x6a\x85\xd3\xd0\x6b\xbe\x03\x34\x20\x49\x62\x6d\xfe\x2e\x59\x4e\x9c\x5b\x72\xd1\x21\x5d\xbd\xf4\x75\x7e\x92\x4b\xa2\x8c\x57\x81\x8e\xf1\x2a\x0a\xec\x5c\x4e\xd9\x8d\x3c\xa2\xa3\x4b\x10\xb4\x17\x5f\x1c\xbb\x1f\xef\xa8\x32\x36\x4a\x98\xec\xc4\x3a\xd5\x5a\x2a\x3b\x1f\x04\xb4\x65\x7c\x9e\xf3\x0b\x7f\x71\xa7\xc7\xde\x87\x5a\xf5\x27\x79\xb3\x24\x72\x72\xe2\xd8\x6b\x75\x96\x0a\xb6\x3c\x06\xf1\xe9\x21\x0e\x44\xeb\x48\xfd\xda\xbc\xb3\x73\xe4\xa5\x28\x55\xba\xe0\x44\xa8\xe3\x32\xc2\x28\x84\xb0\x06\xa9\x08\xb9\x4a\x8e\x7b\xc8\x3b\x2f\xd9\x83\x68\x2a\x9b\x4e\x03\x59\xde\xd7\x0c\xf6\x80\xb0\x83\x7a\x2a\x13\x70\x16\xb1\x45\x53\xbe\x9c\x79\x12\x0f\x68\x76\xda\x5c\xaf\xc4\xb3\x53\x1b\xa6\x09\xb3\xf3\x2c\xbe\x81\x7c\x5a\x69\xbd\x01\x39\xed\x77\x9c\xbf\xd1\xa9\xc4\xf5\xd1\x57\x71\x88\xaf\xc3\x4c\x58\xc1\x62\x9c\x08\x23\xee\x04\xe4\x28\xf9\xf8\xf1\x1e\x1d\x60\xce\x18\x03\x2f\x13\xcf\x75\xfd\x73\xf7\x35\xe1\xbc\x69\x63\x18\x0d\x56\xf6\x65\x36\x56\xb0\xe1\x19\x8a\xc9\xf5\x50\x68\xb4\xc0\x20\x26\x80\xee\x45\xc8\x68\x30\x27\x91\xbb\x4f\xc5\x59\xd0\xea\xbd\x80\xfc\x98\x34\x4c\x2b\x5f\xb6\x8b\xf0\x4f\x1a\x9a\xee\x0a\x10\x50\x0a\x03\xb0\x97\x07\x92\x0b\xdf\x78\xa0\x7c\x49\x3a\xa5\xc4\x8c\x06\xe6\x05\x2c\xf9\x00\xed\xa8\xaf\x67\x05\xc6\x0c\xe6\xc9\x19\x56\x13\x93\xa6\x4b\x30\xab\x26\x1c\xb8\x5a\xef\x85\x23\xb1\x02\x8b\xda\xc9\x7b\xb8\x6b\x48\x39\x0a\xfe\x72\xd7\xe6\xa1\x4d\x7d\x86\x3b\xc4\xbc\xa0\x93\x66\xd0\xb5\x55\x66\x12\x47\x65\x9c\xc8\x69\xb9\xbb\xd5\x96\x13\x6c\xf0\x2c\x26\xc8\x36\x9d\xde\x8e\x63\x09\x49\x1e\xf4\x11\xef\x66\x0c\x5b\x45\x70\x1a\xbf\x73\x14\x4e\xbb\xe2\x8f\xe5\x88\x3d\xf1\xf5\x51\xf7\xfc\xa3\x23\x12\x6d\xd3\x20\xf8\xe5\xd9\xd6\x4a\x77\xeb\xbb\xe4\x2c\xef\x1c\x16\x88\xf5\xdd\xd2\x5a\xcc\x24\x5a\xb6\x33\x70\x41\xd4\x7d\x19\x39\xc2\x14\x0c\x40\xee\xb4\x8c\xb2\xee\x73\xe0\x44\xbc\x72\xa8\xa9\xa3\xdf\x29\xb3\x8f\xe3\x04\x75\x9e\x65\xdd\xec\x7d\xc1\xbb\xae\x8d\x1c\x37\x3d\x36\xe6\x9d\x9b\x00\xdc\xf7\xfb\x96\xf9\x59\xe0\x14\x33\xe5\x09\x4f\x80\x00\xde\x2c\xde\xa0\x94\x6c\xf6\x9b\x99\xe4\x1c\x34\xa5\x7d\x27\x4d\x04\x93\x71\xc4\x6a\x3c\xa0\x6a\xd9\xd4\xe5\xf4\x79\x4f\x28\x81\xe8\xd9\xb1\xee\xa2\x4b\x96\x88\xe6\x96\x03\x6b\x3a\x5b\x43\xc4\x53\x14\xdb\x37\x42\x98\xfe\x0d\xca\xd3\xcd\x1a\xb5\x98\x85\x16\xa0\xa0\x01\x00\x1f\x3a\x5f\x32\xa7\xa8\x02\x15\x40\xe2\x79\xe8\x15\x2e\x0f\xae\x28\x1b\xf1\x60\xe8\x44\xa0\xc4\xab\xaf\x62\xd7\xe7\xb0\x53\x56\xf4\x65\x04\xc7\x4e\x3c\xbb\x9c\x9c\x68\x91\x05\x17\x72\x2a\xb6\x8e\xe2\x44\x9b\x37\xee\xd1\x09\xca\x8d\x03\xe5\xdc\x8c\xf0\x23\x62\x2e\xdf\xf7\x87\x76\x74\xe7\xa5\x04\xc0\xb5\xb0\x14\x66\x46\xc5\xc7\xe1\x84\xc3\xd3\x11\x68\xab\x21\xf3\x2a\xd1\xef\x00\xab\x37\xce\xea\x62\x53\x9f\x69\x20\xba\xeb\xe9\x91\x37\x89\x06\x82\x05\x39\x0d\x0e\x4e\x81\xac\x2d\x37\xb9\x17\x6f\xb4\x5d\xdb\x41\x36\xa1\x03\x6b\x91\xd1\x96\x9d\x89\x6d\x25\xfe\x23\x24\x69\x8f\xeb\xc0\xc0\xb0\x94\x50\x2e\x85\x74\xc6\xf0\x07\x70\x78\x60\x06\xa6\x45\x1d\x0c\xf0\x42\xb3\xbe\x7f\xc5\xc1\x4a\x31\xae\x25\x28\x23\x94\x2d\xb0\x38\x2e\xa2\x62\x41\x48\x82\x40\x6d\x43\x15\x18\x73\x9b\x75\x61\xde\x34\x13\x02\xe7\x0c\xf2\x6f\x53\x3a\x8e\xa0\xf2\x8a\x7b\x7d\x94\x81\x1a\x1d\x6d\xb6\x81\x2e\x7c\xc4\x8d\xfd\x68\x9c\x6a\xd6\x12\x5c\xe4\x25\xf2\xc6\x5e\x26\x60\x44\xcd\x93\x22\xdb\x13\x2e\x27\xd2\xd2\x79\x4a\x32\xfd\xd1\xd7\x76\xf4\x95\x36\x37\x9c\x91\x85\x31\x68\x1d\x52\x5e\x35\x8a\xbf\x8b\xb0\x03\x55\x61\x1f\xa9\x4e\xc6\x8c\xd4\x49\x0b\x80\x21\x0b\x22\x31\x9b\xb2\x4a\x28\x8b\x89\x64\x29\xcd\x86\x67\x9c\x9e\x9d\x09\x31\xab\xc7\x30\xce\xd9\xa2\x4f\x21\x7c\x18\x82\x7d\x2d\x0c\xec\xa7\x86\x46\xa0\x7c\xbe\x83\x58\x94\xf1\x09\x99\x52\x73\x00\xd3\x65\xf5\x6a\x0f\x0d\xc6\xb1\x97\xe1\xf9\xb8\x84\x4e\x4f\xdf\xbb\x5c\xeb\x2c\xa2\xba\xd2\x7c\xe5\xa2\x78\xa8\xbc\xb7\xd9\x94\x5d\xa2\xed\x56\x5c\xb4\xde\x4d\x53\x0f\x98\x50\xbe\xaf\x7a\x90\x1f\x50\xe1\x9b\x8b\xcc\xa2\x78\x28\xb2\xd0\xb0\x3e\xc1\xf0\x99\xdf\xa0\x93\x21\x24\xe5\x1e\xf0\x5b\xad\x7b\xef\x89\xcc\x62\x5f\xbe\x6a\x3b\xb8\x8e\xc1\x2e\x60\x56\xe3\x46\x4d\x45\x3a\xff\x9d\x0b\x84\x6e\x38\x39\xdf\xce\xe4\x41\x69\x0b\x2c\xbe\xda\x3a\x5e\x37\xd5\x2b\x4d\xef\x16\x45\x7d\x6e\xfa\x07\x9f\x04\x49\x21\x7a\xec\x70\xc4\xe1\x03\x9c\x28\x18\x46\x00\x44\x54\x49\x86\xb5\xea\x29\xee\x85\x58\x00\x7f\xef\x03\xae\x74\xf8\x83\x3d\x9c\x1a\xc7\x5f\x01\x04\x27\x74\x8e\xfd\xb2\x97\x86\x89\x3d\xdc\x70\xbc\xc0\x99\xa1\x49\x74\x10\xa1\x28\xcb\xe9\x2a\x56\xa6\x2d\xfa\x5c\x70\xb6\x02\x41\x89\x0c\x34\xe8\xdd\xda\xf2\xa5\xce\xfe\x83\x96\xca\x88\x3f\x86\xd1\x32\xc0\x54\x5d\x39\x76\x89\x19\x93\x2a\xaa\x90\x35\x44\x0e\x11\x85\xa4\x78\x40\x2b\x14\xbe\xb2\x10\x35\x98\xb6\x57\x9f\x5d\x48\x3c\x5e\x04\x0e\xef\x79\xf6\x7a\xb3\x8e\x44\xce\xb9\xf5\x2e\x6f\x9d\x07\x5d\x31\xcf\xc4\x8a\x31\x2d\xa6\x39\x9e\x89\xe7\xae\xf0\xfb\x35\x97\x3c\x66\xa5\x96\x06\xf1\x7b\xff\x4a\xf3\x6d\xcb\xa6\xf0\xd8\xde\xe1\xd4\xc0\xd2\x59\xe0\xd5\x3b\x11\x73\x2a\x2e\x7c\x06\x0b\xe9\xd7\x86\x4e\x79\x7e\xfb\xaf\x6c\x08\xb2\x8b\x39\x69\x1c\xdf\xae\x42\x2e\x93\x61\x1b\xf6\xc2\x75\x8c\xfa\x29\x20\x01\x05\x0d\xfb\x7b\x63\x88\xc7\x6a\xdb\x0e\x78\xab\x2e\xd5\xf1\xc0\x83\x7e\x91\x62\x50\xbe\x38\x18\x7b\x32\x0a\x70\xb1\xa8\xd0\x93\x8c\x1c\xb4\x6e\x5a\x60\x2a\x43\x76\x1e\x9e\x6c\x37\xea\xf1\xdb\xf1\xd0\x17\x8f\x09\x78\x72\x8f\x95\x17\x4b\x73\xce\x8a\xc8\x38\x40\x0a\x29\x20\x12\x09\x4e\x29\xd1\x59\xf5\x0c\xa4\xa4\x68\x38\xe0\x05\xfe\x32\x95\xcd\x2c\x5b\xca\x82\x92\xd1\x8b\xf9\xdc\x5a\xf3\x32\x3f\x68\x76\x94\xc1\xde\xa9\xe9\xd8\xdb\xf8\x45\x49\x2a\x4b\x63\x15\xbd\x6c\x26\x20\x28\xd2\x00\x6e\x31\x61\x51\x72\x33\x51\x82\xfc\x31\x0a\xef\x58\x00\xa5\xaa\x60\xf5\x46\x21\x2f\x75\xa9\x58\x09\x7f\xcf\x93\x71\xab\xcf\x0a\x3f\xae\x72\x50\xc3\x49\x2b\x77\x63\xc1\x42\x70\xd8\xfd\x22\x25\x25\x92\x36\x87\xad\x65\x0b\x54\xd0\x8e\x59\x9b\x07\xb9\x01\x6f\x2d\x80\x28\x66\x75\x47\x9b\x03\x69\x07\x6b\x94\xc6\x90\xfc\xe8\x41\xbd\xd9\x81\x07\x5b\xd5\x5a\x28\x4a\x36\x7c\xef\x6d\x34\x6b\x37\xf0\x49\x14\x64\x56\x64\xd0\xa2\xeb\x69\xbb\x13\x18\x64\xe5\x85\x9c\xb1\x36\x68\x67\xa9\x83\x75\xb3\xa2\xb2\x52\xb3\x9d\xb3\xc9\x5e\xd1\x68\x7c\xb8\x87\xd1\x0d\x25\x81\x1d\x24\x58\x25\x68\x4a\xa1\x78\x5f\x64\x43\x64\x8b\x3a\x9d\xc6\x30\x72\x33\xa2\x1d\xbc\x15\x4d\x13\x33\xd7\x5a\xbc\x47\x6a\xd0\x0f\xfc\xf1\xb6\xbc\x13\xab\x25\x64\x0d\x80\xd9\x7b\xbb\xb8\x9e\x27\xfc\x0e\xae\xd4\xa0\xdb\x2a\xae\x22\x99\x2c\xb9\xc5\x09\x71\x36\x4b\x6c\x88\xa1\x5b\xd8\xf9\x68\x84\x3b\x3f\x80\x4e\x23\xeb\x68\xf6\xa0\x52\xe2\xe1\xf2\x7a\xdd\x62\x92\x1d\xd9\x16\x3c\x74\x73\x35\x59\x35\xbd\xe3\xfa\x4e\x52\xd4\xa3\x26\x9d\xc2\xce\xcc\xe4\x1d\x95\x37\x6f\xa1\xf6\x76\xb5\x3b\x0d\x7c\xad\x34\xee\x29\x51\x6f\x8c\xab\xec\x14\xb3\x2e\xc2\xdc\xb8\x58\x18\x7d\x5c\x55\xd5\x49\x63\xc0\xd7\x4b\xac\x1e\xc3\x88\x6a\x0e\xa9\xe1\xf5\x95\x99\x7c\x4e\x1d\x33\xf7\xa2\x8b\x57\xe7\x6f\x8c\x82\xf4\x99\xea\xdf\x05\x77\x94\x47\x78\x3f\xca\x1c\x8f\x88\x14\xbd\x36\x38\xc4\x18\x5b\xaf\x5d\x43\x0c\x88\x06\xcf\x66\x0d\x0f\x30\x58\xd9\x93\x17\x3b\xb3\xd9\x35\x61\x52\xa4\x62\x59\x5e\x47\x15\xb2\x7f\x06\x19\x4a\x04\x19\x56\x9f\x74\xb9\xa9\x7e\x7f\x90\x59\xcf\x3f\x16\xca\xf4\xe9\xdf\xa7\x29\xb6\x7e\x4b\x0d\x78\x3d\xbc\x52\xb5\x56\x0f\x9a\x52\xd7\x3b\x1d\x97\x35\x1c\x0e\x14\x1f\x08\xab\x18\x15\x8d\xb7\x37\xf2\x26\x6e\xd0\x7e\x94\x3c\x71\xcc\x69\x28\x3b\x85\x32\x6d\x6d\x39\xc7\x56\x54\x3c\x69\x79\xb4\xc1\x02\x37\xc7\xa0\x9e\xc2\x2e\xcf\xdb\x0c\x7d\xb3\x72\xaa\x0a\xed\x9d\xef\xbb\xbf\xeb\x7a\x9e\x27\x1a\x12\x39\x6c\x3f\x10\x39\xec\xae\x48\x6a\x8f\x0f\xca\xd7\xb2\x47\x4e\x81\x1b\xf0\x8e\xdd\x71\xc7\xcb\x17\xf1\x76\x9e\xf5\xd3\xa6\xd5\x97\x80\x3f\xce\x80\x38\xa4\x43\x17\x42\x35\xd6\x6a\x33\x4a\x15\x72\x67\x01\xa8\xb0\x07\xc9\xae\x6c\xfd\x7c\x11\xcd\x43\x6b\xdd\x14\x50\xec\x07\x68\xeb\xa2\x3e\x6a\x80\x75\x5f\x46\x83\x80\x27\xad\x9e\x94\x15\x12\x21\x4c\x0f\xe4\x89\x32\x5a\x9d\x09\x36\x6e\xc5\x2c\xe8\x5b\xe3\x7d\x44\x2f\xcd\xa3\x88\x5a\x7c\xb3\xca\xd0\x1a\xc5\x8b\x34\x41\xb6\x70\xe4\xfe\xa9\x8b\xad\xe8\x8d\x8d\xb3\x22\x89\xfe\x3e\x1b\x5b\x73\x9e\xd0\x3a\x2f\xaf\x91\x40\xcd\x8a\xf4\xc7\x29\xba\xd7\x69\xd8\x5e\x13\x66\xc9\x86\x24\x75\xa1\x35\xf1\xc7\x32\xa4\xdc\x22\x4a\xcd\xb3\x49\x2e\x25\xd8\x71\x31\x8b\xf2\x44\x39\x11\xc1\x79\x37\x1c\x87\xd4\x9c\xcd\x9e\x6a\x08\x52\x04\x33\xe7\x0c\x22\x38\xec\xb6\x04\xa5\xb7\x20\xbc\xce\x4a\x05\x7a\xb4\x17\xb0\x52\x81\x29\x6a\x19\x53\x8e\xec\xd1\x5a\x30\x72\x26\x57\x54\xa7\xc6\x0c\x3b\x87\x66\x43\x6a\x2b\x69\x2c\x65\x6e\xfc\x5b\xf0\x46\x82\x34\x4c\xd7\x67\x72\xa3\xe2\x5c\xc0\x41\x79\xca\xaa\x0c\x74\xc4\xfa\x82\x62\x23\xf4\x86\xf3\x4a\x2c\x69\xac\xc0\x44\x95\xa1\x0e\x2d\x1d\x04\xbd\x09\x7a\x41\x77\xaf\xf2\x0d\xae\x1c\xce\x22\x86\x35\xce\x04\x42\xb3\x9a\xcc\x2a\x79\x3e\x3d\x2e\x82\x9a\x1e\x0c\x2d\xe1\xb3\x47\x0d\x86\x41\xb9\xb1\x6e\x42\x1a\xc6\x23\x5a\xbb\x28\xa4\x25\xa9\x2b\x1d\xe6\xc6\xd4\x81\x6f\x1d\x15\x5d\xaf\x8f\xba\x94\x6c\x9c\x33\xbe\x36\x31\x58\x19\xfc\xf0\xb2\x22\x06\x03\xf2\x26\x5d\xb5\x69\x44\xec\x7d\xe8\x2a\x71\xb2\x87\xd0\x0e\x17\xc3\x93\x5d\x83\x93\xb2\x45\xcc\xa4\x05\x72\xb2\x96\x6e\x45\x1c\x64\xa4\xa0\x6f\xb8\xa6\xb3\xea\x43\x0d\xf0\x09\x2e\x45\x79\xb2\x39\x43\xe8\x68\xd8\x4f\xb4\x77\x02\xe4\x67\x9a\xab\xcc\xdc\x00\xd9\x01\x64\xe9\x7d\x95\xfb\x6e\x77\x14\x99\xa6\x43\xe2\x9a\x93\x00\x73\x73\x54\x46\x1b\x8a\x4d\x63\xc8\x94\x03\xfe\xd0\x7b\xbb\xf0\xf3\xbc\x02\x8a\x58\x08\x3a\x85\xdd\x75\x4b\x34\xa8\x11\x95\x1c\x0c\x5a\x82\xfb\x09\xf3\x18\x48\xdc\x32\xe5\xef\x83\xa6\xa6\x41\x0f\xdd\x45\x87\xfb\x05\xa4\xba\xaa\x02\x20\xec\x06\x6f\x7a\x71\x96\x0d\x54\xf8\xdd\xbb\x7d\xed\x40\x05\x8d\x89\x6f\xeb\xaf\x55\x4e\x6d\x36\x89\x3d\x25\x9c\x18\xc3\x3f\x36\xa0\xc5\xc6\xfc\x88\xd9\xde\xe2\x17\x9b\xe0\x3c\x92\x44\xba\x54\xd8\x21\x80\x08\x24\xe4\x77\x7e\xc8\x70\xfc\xc1\xf6\x36\x03\xf7\x15\x68\xac\x3a\x0b\xb1\x8e\x9e\x6b\x05\x08\x62\x25\x83\xcc\x46\xf9\xf2\x8a\x98\xb6\x8e\x46\x2e\x62\x0e\x1a\x8e\xad\x8e\xe8\xca\x58\xfc\x73\xf4\x1f\x0c\xa6\x76\xf1\xea\xb3\x8b\x40\x2b\x9d\x48\xc6\x2c\xf6\x56\x86\x57\xd0\xf2\xe2\x69\xb2\xe2\x52\x8a\x93\xdb\x3e\x3a\x03\xab\x5f\xc0\xcd\xb9\x74\x8c\x38\xeb\x16\x6e\x11\x4e\xa0\x28\x8e\xcf\x2d\xcc\xd1\x2c\x8b\x52\x2d\x4e\xec\x7a\x8a\x2a\x42\x50\x69\x3a\x9e\x08\x4f\xd2\xf1\xaa\x17\x7a\xad\xdd\xde\x46\xcb\x33\x96\x08\x16\x9d\x2f\xaa\x5f\x05\x98\x1a\x37\x1d\xf0\x89\x0a\x1f\xf6\xa6\xdd\xb6\x8a\x7d\xbd\x09\x8b\xc9\xc6\x48\x19\xe9\xc4\xa4\xe9\x29\x02\x5c\x86\x8e\xd4\x4d\xac\x2d\x4f\x87\x50\x67\x6c\xb1\xfe\x61\x30\x03\x7d\x63\x41\x89\xcb\xf2\x5d\xc2\x8b\x08\x29\x9b\x53\x75\xfa\x6a\x9a\x57\x34\x0d\x69\x0d\xaa\x4c\x3b\x04\x95\x68\x5b\x76\xf5\xe8\x04\x88\xf0\x36\x90\x74\x72\x82\x5e\x42\x5d\x1a\x3c\x34\xb9\xa5\x16\x79\x29\x1d\x9d\xa0\x8d\x28\x0f\x28\xd9\x62\x38\x45\x14\x0e\x1f\x9c\xf3\xd6\x3f\xd0\x77\xaf\xb6\x5c\xf8\xe0\xe5\xca\x20\x99\x1a\x8a\x70\x72\xda\x96\x4c\x11\xf7\x5a\xdd\x51\x59\x8d\x2c\x6a\x43\x16\xcf\xad\xe6\x07\x5c\xbd\x5c\xd1\x95\x03\x2b\xbe\x40\xc7\x4e\x39\xe7\x15\xf6\xdb\x8b\x0c\x28\xc1\x28\x5c\x4d\x62\xdf\xe8\xa6\xf9\x15\xe2\x2c\x69\x74\x1c\x0e\xc8\x59\x39\x66\x47\xd6\x70\x1d\x18\x63\xee\x5b\xa3\x37\x05\xef\x8d\x8c\x7c\x21\xdc\x2b\x82\x6b\xb1\xa3\xe7\x89\x63\xb8\x1e\x9b\x4b\x59\x37\x11\x97\xef\xcb\x5d\xb3\xc9\x00\xf6\x94\xa4\xae\xf2\xc4\x20\x97\xc9\xcc\x4b\x27\x01\xf8\xe9\xa9\xca\xef\x98\x2a\x89\x5e\x24\x55\xa6\x66\xc7\x71\x48\xce\x85\x10\x68\xb5\x59\x73\xde\xa6\x0f\x1d\x18\x34\xaa\x71\xe4\x77\x03\x4c\x1c\x3c\x32\x01\x8d\xc9\x6b\xf3\x32\x73\xef\xbe\xa2\x68\x90\xe7\x29\x65\x22\x8a\x39\xae\xe8\xe5\x3d\x3b\x10\xa0\x75\xda\x84\x1b\xee\xc2\xe9\xa4\xef\x3c\xc3\x74\xa4\x29\x31\x25\xce\x91\x57\xbb\xd7\xe9\xcc\xc4\x9f\xca\x31\x64\x01\x47\x40\x74\x70\xb9\x3d\xcd\x85\x23\x6d\xcf\xe6\x4a\xef\xe8\x3a\x40\xd6\xfa\xb2\xb4\x59\x3e\x2b\x7d\x62\x59\x12\xc9\x9b\xc0\x7e\x74\x22\x38\xa7\x43\xe6\x54\xc2\xd3\x0f\xdd\xcd\xd0\xc7\x45\x94\xa7\x03\x32\xba\xbc\xca\xed\xa5\xd7\x48\xaa\xf2\x2e\xab\x15\x88\xcd\x01\x85\x12\x52\xa7\x7a\x09\x5d\x54\x59\x47\xdd\x1a\xf8\xec\x4d\xcc\x72\x5f\x52\x3e\x9e\x95\x83\x66\x29\xa2\xa8\xe7\x3d\xaf\xbd\x7d\x5e\x55\xbd\x37\x7e\x3a\xb9\xdb\xa6\x01\x13\xd7\x2a\xdc\xcd\x25\x2a\xd0\x4c\x61\x3d\x71\xa6\x14\x0a\xc6\x48\x44\xe7\xe1\xc7\xd4\xd9\x33\x76\xff\x3c\x9f\xce\x66\x24\x12\x51\xed\x78\x8b\x1a\x68\xf6\xbc\x15\x7e\xae\x08\x88\x65\x24\xae\x1f\xc8\x42\x58\x93\x7c\xc6\x8e\x38\x76\x7d\x67\x9a\x9e\x04\xfc\x00\x6f\x02\xef\x61\x47\x5a\x9f\x8f\x14\x7d\xf6\x78\x24\x1c\x2c\x4f\x92\x82\x2f\x0d\xe4\x16\xbe\xdb\xfb\x77\x3d\x76\x4f\xcf\x3f\xda\x9b\xc0\x5f\x7f\x0f\x60\xfd\x9c\x75\x04\x7a\xfe\x56\xbb\x35\x1d\x04\xa8\x61\xde\x9d\x14\x47\x2e\x97\x44\x94\xcb\x8d\xe4\x62\xb2\xc6\xc8\x1d\x01\x18\x6f\xb0\x50\x1b\xbd\x5d\x3f\x3b\x37\x7d\x90\xef\x64\xa3\xe1\xc9\xa8\xce\x6e\xbe\x30\x16\x6c\x3c\xce\x15\x8d\x47\x2c\x5f\xd0\x1a\x73\x52\x07\x67\xdd\xe5\xdb\x5b\xcd\x27\xd1\x03\x61\x9a\x63\xc9\xd2\x5c\xe9\x7b\x58\xd7\x52\x1c\xdf\x2c\x0c\x9f\x8f\xe7\x4e\xe3\x44\xd6\xe0\x79\xc8\xde\xe3\x06\x93\x81\x33\x59\xc4\x2a\x1b\x7c\xa8\x2b\x63\x04\xbb\xbe\x0e\x6e\x1c\xdd\x49\xc0\x6b\x25\x34\x85\x86\x27\x60\x93\xe2\x64\x41\xe3\x46\xbc\xe2\x3d\x15\x06\x75\xb1\x62\x45\x66\xdf\x66\xb7\x3b\x90\x97\xbc\x7b\xbb\x36\x39\x06\x57\x95\xa7\xc7\x5b\xba\x24\x88\xd8\x42\x22\xb2\xe9\xa9\xa4\xe7\x32\xfa\xa9\x04\xd9\x09\x57\x74\x97\x8f\x9b\x58\x3e\x8d\x85\xb3\x2e\xf5\x34\x34\x84\xdf\x7d\x41\x38\x34\x09\xf3\x3d\xeb\x12\x93\xe6\xb5\x63\x82\xb1\xf4\x35\x79\x72\x09\xbe\xdb\x35\xe4\x1e\x54\x81\x44\x3c\xfe\x72\x53\x4a\x30\x38\xba\x79\xa4\xb1\x9b\x9c\x6a\x7a\x64\x3b\x51\xd8\x16\x4b\x23\x28\xba\x88\x94\xb6\x41\xb2\xb2\x0c\x12\x77\x4f\xd1\xa2\x13\x7b\x4d\x67\x0c\xd5\x06\xd3\xdd\x23\xae\xef\x1f\xd1\xcc\xcb\xe1\x1b\xa7\xe7\x14\x35\x72\x85\xb1\x01\x5c\x1e\x29\xf5\x85\x24\x44\xce\x39\x5c\xcd\x8d\xd0\x91\x36\xd8\xd2\xe5\xad\xb9\xc8\xf2\xa4\x46\x38\x5b\xe4\x92\x04\x93\x09\xa4\xc9\x6d\xb5\x42\x23\xdb\x51\xb6\x91\xf7\x45\x3a\xf6\xdb\x38\x38\x38\xe5\xac\x26\x5f\x55\x76\x86\xe7\x7e\x65\x4e\x9d\xfc\x90\x37\xa6\xc7\xec\x71\x0f\x86\xa2\xa3\x4c\x29\x99\xb5\x43\x94\x14\xd1\x3b\x3b\xf5\x91\x6a\xcb\xa5\xc8\xf3\x65\x90\x91\x34\xd6\xd2\x13\x20\xcf\x99\xd7\x60\x6b\x4a\xc3\x15\x6f\xe4\x50\x9a\x6f\xc9\xa3\x0a\x74\xac\x04\xf6\xbd\x05\xaf\xdd\xc5\x32\xd0\xd1\xae\xec\x69\x5f\xf9\xba\xd3\x68\xfb\x28\x42\xea\x65\x09\x92\x7d\x8c\xd6\x89\x4c\x88\x94\xd9\x8e\x1c\x9d\xa5\x3f\x98\x28\x5e\xe2\x66\xff\x80\x2b\x6e\x68\x25\xf8\xdc\xf5\x32\x8a\x31\xa1\x90\x78\x60\x94\xf0\x7a\x79\xeb\xc8\xe2\xf8\x8f\x3a\xac\xe8\x82\x5d\xbc\x14\x60\x6a\x01\x15\x67\x2b\x18\x29\x87\x9c\xc1\x4b\x18\x6f\x6b\xf0\x65\x4d\x87\xd0\x08\xd3\xa8\xb2\x4f\x4b\xf0\x4e\xfc\xe7\x24\x06\x2a\x64\x8a\xf1\x86\x55\xa0\x5c\x09\x0c\x4a\x01\xbc\xad\x0a\x3c\x08\x37\x36\x3f\xb2\x0a\x2e\xbc\xc0\x43\xe0\x34\xef\x28\x27\x26\x7c\x58\x63\x43\x69\x2b\xcd\x04\x12\x53\x86\x2c\x52\x98\x89\xfc\x8e\x83\xab\x27\xa7\x98\x56\x63\x7f\x3c\x46\x57\xe7\x62\xb6\x2f\xc0\x48\x96\xf8\x38\xb8\xe5\xe7\x88\x1c\x62\x56\x28\x6d\xc2\xea\x5d\xba\x3e\x98\xda\x8f\xef\x64\x39\xb9\x96\xbe\x7a\xf3\x38\x5c\xf2\xf0\xb0\xb2\x9e\xb2\x02\x0c\x57\x14\x7a\x5a\x01\xed\xd1\xd2\x1e\x67\xa0\xd3\x43\x84\xc3\x9c\xb8\x50\xcc\x0b\x2c\xb2\xd5\x2a\xf8\xcd\x01\xd7\xda\x0e\xe5\x2d\x01\x31\x2f\x8a\x2a\x48\x29\xbb\x26\xaa\x24\x40\xf6\xfd\x7b\x3f\x71\xcd\xc6\x3f\xd8\xb9\x67\xd7\xfe\xfa\xa2\xdf\xcf\x5f\x2e\xca\x55\x8e\x66\x5d\x72\x4e\x07\x6b\x62\x49\x50\x76\x21\x04\x73\xa4\xd4\x91\x54\x48\x19\x20\x49\x06\x08\xae\xf6\x37\x78\x5b\xa5\xc9\x7e\xdf\x08\x43\x1c\xc3\x3c\x2f\x06\x7b\xc6\xdc\x48\x72\x36\x68\x07\x23\x48\x87\xaf\x51\x24\xab\x4b\xcd\xd5\x9d\xea\xf7\x0e\xe2\x86\x88\xd8\x7c\x58\x39\xf0\x84\x78\x11\x38\x71\xe2\x78\xf9\x56\xc1\xc3\xcc\xf1\x2d\xd7\x97\x09\x0f\x21\xcb\x08\x0e\xc8\x90\xc8\x86\x39\x8d\xa8\x75\xc2\x08\xf6\xc4\x57\x79\xc1\x45\x17\xce\x4f\x34\xde\x1e\xf7\xab\x11\x15\xaa\xa1\x33\x93\x96\x2a\x2c\xde\x72\x59\xad\x2b\xf0\x5d\x1e\x15\x6d\x98\x58\x55\xad\x69\xb4\xda\xbb\x81\x2a\x97\xa6\x28\x6c\xe5\x25\xc1\xd6\x74\x70\x87\x84\x65\x17\x4f\x4f\xca\x7f\xc2\xdc\x35\x9c\x9b\x80\x9f\x64\x1b\xef\xe3\x24\x9b\xf2\x33\xb7\x41\xdd\x8b\xcd\x83\xed\x18\xf6\xaa\xae\xa7\xe1\x16\x80\xfb\xe4\x35\x10\x5a\xb5\xe7\x2a\x2b\x6c\x00\xe9\xe2\x05\xcb\x2c\xd9\x76\x92\xc9\x28\x7e\x0c\xda\x59\xa8\x3c\x7a\xa2\x40\x54\xa1\x55\x24\x54\x10\xa9\x2d\xe8\xad\xdb\x9f\x1e\x4c\x9b\x2c\x86\xd2\x00\x0c\x21\x0c\xe5\xd3\x9b\x45\xa7\x6e\xf5\x64\x5c\x02\xde\xb8\x2d\x58\xf1\x86\x88\x2a\x77\x39\xf3\x3d\xd5\xa0\x19\xf2\xc9\x10\xe3\xfa\xd2\x23\x9f\x35\x9d\xfa\xd0\x6a\x36\x34\xb8\x32\x34\x46\x42\x81\x2e\xd6\xac\xa6\xc0\xa4\x1b\x7d\x05\x6e\xf4\x35\x14\x36\x3f\x09\x86\xc2\x3e\x29\xa5\x70\x3a\x1a\xf3\x79\x06\x25\xdb\x6a\xa4\x44\x4e\x6e\xe2\x32\xea\x65\x81\x0f\x14\x8a\x99\x0c\x24\x64\x19\x50\x23\xe3\x5c\x69\x87\x97\x26\x9e\x07\xbf\x97\x6e\x71\xd9\x42\x4b\xc2\x67\x33\x74\xb5\x00\x14\x59\x41\x15\x8c\x63\xaa\x3b\x96\x47\x4c\x4c\x85\xe3\xfb\x01\xac\x42\xe3\x90\x63\x93\xda\x24\xa0\x1f\x21\xa9\x9f\xfd\x7a\xa4\xce\x55\x07\x24\xf0\x08\xd5\x49\x12\x6a\xa5\x50\x89\x6a\x07\xb0\xdb\x5c\x21\xbe\x50\x23\x91\x85\x9e\x91\x2b\xd6\xbd\xd5\x81\x0c\xaf\xe7\x5d\x79\x5f\x69\x06\x3a\x24\x0b\x31\xf5\x63\xc4\xb7\x59\xa6\xf5\xbd\x09\x9b\x8d\xc8\x24\x51\xd1\x2c\xd5\xe9\x9b\xdd\x2d\xc5\x01\xe7\x03\x91\x82\x4f\x4b\x0e\xd2\x72\x20\x9f\xd9\xec\xf3\xae\xec\x8f\x3b\x77\x86\x47\x4a\x0d\x7d\xcf\x60\x2f\xdd\xc0\x03\xf6\x50\x11\x0d\x39\x0f\x55\x3f\x93\x97\x19\xb0\x2f\xbc\x40\x38\x31\xb9\x1f\xcd\x9e\x77\x3d\x09\x06\xb7\x28\x89\x17\x8e\x03\x1d\xa8\xd1\xd3\x62\x37\x0d\x6d\x5f\x8b\xac\xd7\x12\x0f\xef\x95\x92\x55\x18\xcc\x77\x70\x43\x6b\x98\xe3\x4d\x89\x9a\xd5\xf5\x99\x25\xaa\xde\x9d\xcb\xc0\xc9\x6b\x30\x8c\x98\xf3\xae\xe6\x40\x21\xbc\x35\x41\x35\x61\xba\xef\x5e\xf4\x85\xe9\xd9\x47\xb8\x96\xab\x92\xa9\x25\xf2\x2b\xc2\x34\x5c\xad\x3d\xbc\xcf\xef\x30\x9d\x53\xbc\xbe\x6d\x84\xa4\x48\xba\x84\xdf\xfc\x52\xc2\x7c\x92\xfe\xae\x59\x47\x76\xfe\xc1\x7e\xd2\x60\xf8\xe5\xc5\x08\xb0\x79\xad\x5f\xce\x46\xcf\xf9\x11\xde\xbb\x29\x69\x18\xd4\x3a\xa4\x11\xc9\xa2\x01\x72\xae\xc4\xd5\x14\x95\x0e\x62\x33\x33\x8c\xb0\xf9\x52\x85\xbc\x7b\x61\xf5\x1f\x02\x5d\x7b\x08\xf8\x32\x00\xa3\x13\x6c\x33\xa2\x4d\x73\x28\x45\xa9\xca\x8b\xaa\xa2\x44\xda\x36\x36\x88\xe8\x84\xbc\x4f\x70\x55\x48\x1e\x6a\xcb\xd2\x72\x7a\x86\x37\x4a\xa0\x77\xfe\x48\x70\x18\xef\x19\x2c\x1e\xb4\xe0\x3e\x25\x85\xc6\xde\xe5\x91\xd5\x78\x06\x40\x88\xd0\x68\x38\x4e\x2c\x38\x8f\x75\x6a\x9d\xb0\x47\x2e\x87\xd0\xf3\x01\xa4\x8f\xac\x7b\x98\x71\x54\x44\x5c\xb6\x43\xaf\x89\x1d\xc3\xe3\x96\x0b\x38\x4c\x9a\x89\xd6\x85\x67\x9f\x5b\xaf\xd2\x4a\xc4\xf4\x2a\xa9\x0c\x93\x26\x9b\x87\xf5\xfc\xb2\xed\x4c\x99\x0f\xae\xdc\x63\x39\xbd\x08\xe0\xac\x50\xa3\x68\x7d\x05\xbc\x78\x69\x91\x99\x24\x09\x03\x5c\x61\x44\xf2\xf0\x84\xd1\xca\xb3\xd9\xa3\xca\x87\xf9\x7e\xf5\x15\xe2\x5c\xad\xcb\x9a\x2f\x35\xc0\x74\xa1\x06\x37\x6b\x74\x64\xb0\x3c\xef\xdc\xee\xbc\xc5\x59\xfb\x81\x3d\x34\x78\xce\x66\x0c\xa9\xd9\xeb\xac\x3a\x0c\x10\x2e\x0c\x67\xfc\x48\x60\xcf\x5d\xf2\xe1\xfa\xc0\x69\xff\xe5\xd7\xb9\x66\x3a\x29\xd3\x6a\x43\x59\x3a\x48\x4e\xba\xb5\xa8\xd0\x7a\xdc\x11\xee\xf3\x12\x27\x19\xe2\x8a\x60\x7d\x84\xdd\x12\x26\x3b\xd2\x0a\xaf\x77\x8c\x6e\xa3\xcf\xe0\x8f\xd2\x55\x6b\xd1\x34\xa2\xd7\x94\x31\xc5\xcb\xb1\x03\xdd\x41\x13\x3b\x39\xad\x06\xe9\x2d\x1c\x24\x7c\x9b\x41\xe1\xb0\x1c\x99\x87\x18\xa8\xa4\x5e\x3f\x6c\xea\x26\xe0\x3c\xac\x6e\x74\x10\x5c\x84\xd4\x9f\x39\x9f\xb6\x97\x10\x8a\x8d\x18\x36\xb3\x88\xf3\x57\xd9\xcb\x04\x1d\xfa\xd7\x83\xac\x0a\x6c\x7c\x3e\x04\x83\x0c\x40\x10\x26\x13\xee\x45\xba\x2b\xcf\xe7\x8a\xc7\x13\xbe\xad\x21\xaa\x12\xa2\x89\x02\x7a\x64\x75\x0e\x36\x72\xbb\x9d\x2e\x90\x8c\x55\xa9\x03\x5c\xde\x02\x09\x9c\x45\xc6\x78\x5c\x1d\xbf\x8b\x97\x00\x93\x78\x23\xf7\x3e\xd8\x0c\x6c\xa2\xa7\xf6\x06\x5c\x6d\x61\xf2\x61\xa1\xd5\xef\x1d\x7e\xdd\x83\xe5\xd3\x2f\x2a\x94\x18\x53\xd6\xda\x83\x67\x5d\xd0\x95\x5c\x5e\x05\x2f\xa4\x1e\x48\x5d\x7b\x2e\xa3\x1f\x9f\xd8\xf2\x16\x32\xe6\xb9\x99\x62\xc0\x3b\xf4\xe9\x5a\x66\xcb\xac\xcf\x9c\x7e\xcd\xf9\x9e\x30\xfd\xd2\x49\x8f\x54\x8b\x94\x62\x20\x17\x8c\x74\x95\x50\x97\x24\xdc\x4b\x4b\xb6\x71\x2e\xfb\xc5\x4b\x23\x95\xb7\x16\x95\xb8\x32\x63\xef\x23\x43\x1d\x10\x7f\x1b\x93\x61\x3f\xb5\x22\x0a\x27\x47\x2b\x57\xce\x70\x6c\x47\xee\x5d\xdb\xf5\xde\x63\x71\xa1\xcf\x40\x71\xe5\xb1\xc4\x97\x49\x0e\x1a\x12\x21\x9f\x56\xc2\xe6\x36\x86\xed\x1d\xda\xd0\xf0\x63\xc8\x4b\xcc\xbf\x51\x82\x33\xd0\x78\x6c\x76\x16\x31\x3c\x58\x45\xc9\x71\xb8\x86\xb9\x6c\x09\x92\x12\xe5\x9e\x2b\xde\xa9\xad\x95\xd0\xbb\x91\x78\xcc\xb3\x72\x22\x33\x29\x69\xed\xb8\x43\x61\xa4\x6e\xae\x9c\x3b\x8b\xb4\x26\xd8\xf7\xc4\xff\xbc\x8d\x11\xdd\xb7\x80\x25\x9f\x83\x42\xf3\xbb\x02\x4a\xde\xee\x7f\x2c\x40\xe9\xd6\x5f\xb7\x31\xed\x97\x9f\x40\x70\xf4\x78\x59\x94\xc0\xa1\xfd\x74\x8c\x68\xa2\xf0\x06\xcb\x2e\xc8\x8b\xab\x8a\xca\xe4\x83\x87\x5c\xef\xdb\x66\xcf\x00\x42\x22\x88\xaa\x03\xc5\x09\x14\x6a\x90\x1f\xe2\x12\xf5\xa0\x59\x8b\x35\x5f\x49\x62\x58\x58\x22\xcf\x89\x83\x6f\x31\xe0\x0a\x87\x70\xda\xa7\x38\x78\x8f\xa2\x1d\xdd\x5b\xd8\x49\xb7\xfe\xe5\x8c\xb7\x8b\x54\xd6\x30\xe8\x13\xae\x4f\x8c\xb0\x5c\x38\x82\x65\x4f\x3d\xb3\x75\xb4\x0a\xf9\xd4\xe1\x0e\x42\x20\x66\x40\x60\xcb\xb8\xa0\x06\x08\xcc\x2b\xdd\xd3\x05\xc3\xfb\x57\x84\xc1\xcd\x83\x33\xad\x1e\x6f\x81\x38\x2d\xd0\x35\x5d\xc8\x4d\x85\xcb\x0c\x40\x8f\x8c\xa1\x5f\xbb\x92\x4e\xba\x52\x88\xe2\x18\x47\x50\x5f\x6d\x27\x0a\x75\x05\x00\x30\x53\xbb\x04\x56\x01\x57\xf7\xaa\xe1\x5d\x72\xbf\x61\x46\x82\x1f\xd4\x45\x2b\x05\x4d\x09\x48\xa9\x71\x2c\x87\x27\xcc\x78\xeb\xb4\x79\x69\x63\x94\x29\xbc\x6f\x25\x90\xae\xc0\x42\xdc\x7b\xb0\x1f\x99\x06\xad\xb3\x85\x27\x42\xea\x62\xba\xa4\x3b\xcd\x47\xec\x13\xb1\x70\xc6\xa5\x26\x8f\x95\x04\xc4\xf7\xc8\x68\x33\xd4\x60\x2f\x17\xa2\x56\xf3\x7d\xab\xeb\xc4\xb0\x93\x9e\xd5\x01\x80\xdc\x16\x5f\xc7\x28\x42\xa9\x60\x67\xbc\x1a\xe4\x5c\x98\x41\x54\xa3\xcd\x3f\xfb\x29\xd0\x18\x5c\xef\x0e\x2b\xd1\xe1\x67\x0a\x5a\x16\x90\x91\x5b\xf9\x6c\xe7\xa1\xe5\x46\x91\x32\xde\xc6\x01\x8d\x93\x94\x4e\x0b\xd9\x8a\x49\x46\x3d\x49\x89\x16\x9b\x86\x05\xb8\x70\x69\x7c\xc6\x70\x4d\xff\xc0\xc4\x40\xa8\x58\xb0\xa7\xd8\x24\xd2\x7d\xcb\xda\xa5\x9e\x3f\xbc\xc6\xf0\x49\x16\x89\x12\xb2\x8c\x4f\x5d\x95\x46\x2d\x15\x8e\x6c\x50\xcb\x84\x88\x21\xee\x75\x1f\x72\x75\xc7\x69\x7b\xe9\x8a\x2b\xe0\x86\x52\x3c\x24\x99\x0a\xee\x61\x98\xcf\xbb\xbe\xe1\xc1\xbc\x9d\xc1\x1e\x22\xf6\x20\xe4\x4b\x7b\xf9\x86\x87\x92\x2c\x5a\xcf\x9c\x8d\x91\x31\x19\xb8\xee\xfb\xa4\x43\x50\x8e\x60\x6b\x78\x30\x96\x4d\x0e\x4c\x95\xd5\xe8\x75\xd8\x97\x15\xb7\xcb\x53\x63\x99\x21\x2e\xb9\x56\x4d\xfc\x73\x16\x8e\x07\x19\x8b\x6f\xb6\x7e\xfb\x45\x8c\x5f\x18\xd5\xa7\x4a\xd9\xbc\x12\xb3\x11\x84\x98\xc1\x0b\xa4\x60\xcb\x4a\xe2\xce\x25\x2d\x67\x66\x8a\xa2\x8e\x8a\x18\x59\xce\x66\x9e\xb7\xe4\x43\x17\x89\xc6\xfc\x7f\xd9\xfb\xaf\x9e\xd7\x95\x25\x4d\x10\xbe\xff\x7e\xc5\x8b\x06\x0a\xe7\x42\xbd\x44\xef\x3e\xa0\x2e\xe8\xbd\xf7\xbc\xa3\x13\x3d\x29\x89\x9e\xbf\x7e\xa0\xf5\xae\x6d\xba\xea\x1c\x54\x0d\x7a\x0f\x66\x0f\xd0\x0b\x7a\x9f\x95\x62\x24\x83\x91\x91\x4f\x44\x32\xa5\x64\x8a\xe2\x13\x36\x35\x68\x6c\xcd\x78\x82\xc6\x66\x52\x16\xea\xf9\x7d\xd8\x5d\xa5\xd4\xc9\x94\x02\x20\x7e\xb0\xd8\xe1\x5c\xf0\x76\x43\x18\xb3\x15\xfa\xec\x95\x8b\xfd\x6b\x3d\xe6\x69\x2c\x3c\x6a\x8b\x6f\xf0\x93\x56\x8a\x32\x71\xf0\x87\x8c\x60\x18\x5b\xd9\xac\x01\xd3\xa8\x09\xed\x44\xd5\xd9\x44\x5e\x68\xbe\x49\xab\x45\x1d\xe0\xab\xe0\x6e\x48\x57\x00\x23\x39\x78\x38\x59\xb2\x64\xa1\x86\xda\x18\xa3\xc2\xfc\x28\x13\xbb\x26\xc6\x20\x58\x40\x80\xb6\x63\x7a\x7e\x60\xd5\xcd\xdd\xca\x67\x69\xff\xb5\x1f\x96\x56\xcd\xdf\xec\xb3\x8e\x21\xf8\xd3\xb4\xe4\xfb\xae\x03\x58\xde\xcf\x9e\x7e\xf5\x1a\xd8\xa7\xcd\x8e\x82\x07\xed\x32\x27\xaf\xc8\x89\x20\x06\xa3\xbb\xb5\x50\x7b\xab\xc2\xc3\x88\x94\x17\x11\xbc\xb3\xf7\x2e\x10\x35\x04\xe6\xae\x51\xeb\x8e\x34\xb5\xfc\x4a\xb3\x01\xa3\x0e\x12\xee\x2a\xf6\xa9\x94\x91\x73\x5c\xd7\x46\x15\x67\x62\x35\xec\x62\x60\xbd\x5e\x92\x24\x86\x5c\xe3\x83\xc2\x90\x23\xcf\xd1\xfa\x5a\xb8\x2b\x81\x6e\x2c\xfe\xb0\x75\x89\x7e\x14\x28\xa0\x33\x82\x78\x7b\xe2\x35\x30\xa2\x26\x5d\xd2\x93\x68\x78\x53\x03\x94\xe6\x70\xa3\x31\x50\x53\x9d\x54\xab\xf1\x74\x98\x96\x13\xde\x82\x67\x52\x4c\x8b\x11\xe5\xb9\xce\xab\x88\xb6\x27\x47\x0a\x67\x33\xe7\x16\x6f\xfa\x55\x5a\x1b\x30\x68\x3a\xb6\xb8\x85\xbe\xc7\x4c\xfc\x3a\xb7\x9d\xba\x8a\xda\x1f\x01\x0d\xa3\x2c\xd4\x14\x17\x91\x7c\xf5\x09\x3b\x49\x30\x86\x02\x5c\xc1\x16\x36\xc3\x1e\xaf\x64\xbd\xad\xd5\x6b\x0c\xa7\x90\x9a\x77\x03\x2b\xeb\x27\x6c\x4c\x4b\x25\x4f\x78\x26\xda\xa1\xb8\xa4\x2e\x79\xdb\x6c\x2c\xa0\x52\x70\xc5\xdc\x1b\x54\x3d\x68\x86\x6f\x7a\xfa\x55\xf8\xd5\x40\x91\x12\xb7\xfb\x76\xc7\x79\xa4\x12\x4d\x96\xf5\xba\x31\x93\x8e\x75\x6c\x3c\x08\x1e\xd5\xbe\xcf\x11\xba\xd5\x1d\xbd\x10\x75\xc9\x1c\x64\x51\x67\xee\x4e\xb3\x83\x47\xfb\xbb\x57\x15\x7d\x02\xb0\x81\xaa\xa4\xda\x28\x43\x22\x47\x7a\x4d\x97\x34\x96\xeb\x90\xe2\xd1\x64\x64\x5e\x4b\x14\x36\x24\xde\x51\xed\xa1\xb4\x4b\xc4\xad\x12\xf4\x79\x7f\xe5\x53\x27\x3b\x59\xab\x9b\xb0\xc4\xb1\x63\x02\x05\x1b\xfd\x7e\xb6\xfc\x30\xaa\x49\x4e\xde\xf2\x44\x51\x62\x71\xd6\x66\xbd\x49\x48\xba\xda\xf9\x57\x1a\xe3\x7a\x86\x3b\xb6\x83\x20\x8a\x50\x8b\x3c\x7b\xb1\xce\xf9\xa0\x85\xc8\x58\xa9\xed\xe6\x04\x86\x93\x84\xb2\xbe\x72\x8a\xb1\xc6\x3a\x9d\x72\x67\xee\x0b\x62\xcd\x9a\xd5\xb2\xd2\x8b\x10\x70\x34\x89\x88\x18\x4d\x7a\x6f\x81\xdb\x6f\x02\x66\xeb\xf4\x41\xab\x8a\x72\x5c\xf0\x31\x86\x88\x63\x29\x62\x36\xdc\xde\xec\xd9\x4e\x4b\x52\x2e\x12\xca\x89\x57\xea\xba\x25\x47\x23\x35\x9a\xf4\xa8\x03\x2a\x26\x9f\x84\xde\x53\xbe\x04\x74\x04\x06\x8a\xc2\x32\xa3\x78\x25\x3b\x83\x0f\x60\x25\x3c\x16\x84\xee\xf0\xed\xba\xa9\x71\xb8\x0b\xb3\xd8\xbf\xe4\x23\x92\x17\x3e\xe7\x16\x88\x76\x74\x7e\x51\x8b\xa0\x4a\xb2\xdb\x63\xa7\x41\x11\x66\xe1\x3a\xd2\xc1\xc4\x4b\x0c\x27\x77\x1f\x60\x06\x3d\x87\xa8\x21\xd6\x78\x6c\xe5\x9b\xf6\x48\xc7\x01\x7b\x38\xf6\xac\x92\x8c\x7c\xa8\xf9\x5b\x25\x1a\x60\x95\x2b\xeb\xe6\xed\x37\xa1\x77\xf8\x97\x64\x60\x8f\x03\xd8\x4e\x1f\x5d\x25\x86\xc7\x7d\x13\xad\xb8\xf0\xd5\x01\x8a\x90\x6a\xab\x7e\xe4\x51\x29\x74\xb8\xb7\x2a\x14\x18\x80\x92\xd9\x41\xcd\x48\x28\x24\x4d\xb7\x43\xd5\x59\x8f\xd6\xbf\x35\xf3\x5f\x9b\x1c\xea\xbf\x57\x6a\xc8\x9c\x3f\x16\x6b\x76\x90\xb6\x83\xb4\x3d\x3e\xc0\x7d\x52\xc1\x65\x09\x5e\x4f\xb0\xde\x5f\x01\xdb\xdf\x7c\x86\x77\x3c\x0a\x15\x88\x83\x20\xd9\x07\xea\x5f\x10\x41\x71\x1e\x84\x0a\x64\x98\xc5\xd2\xe2\x74\x4c\xec\x68\xc6\x8b\x5b\x8a\xd4\x4a\x34\x33\x5b\xb5\x19\x32\xc4\x3e\xca\x43\x4e\x49\xc4\xac\x3c\x6f\x07\x61\xfb\xbc\x5d\xc9\x2f\x0f\x24\x2c\x0d\x0b\xd5\x5a\xd2\x30\x09\xc5\x95\x1b\x0c\xbf\x60\x78\x9b\xc3\x67\x16\xee\xc5\xe8\xa0\x93\x42\x82\x9a\xd1\x5c\x70\x7e\x89\x7e\xcb\x1b\xf5\xd6\xa2\xf9\x22\xf3\x68\xf8\x6e\xc9\x68\xb0\xfc\x5e\xd5\xa8\x91\x8d\x73\x53\xb8\x78\xaa\x85\x4c\xd5\xf5\xd8\xa2\x2d\xde\x4b\xa3\x15\x6f\x42\xad\x83\xea\xe2\xb7\x3d\xc4\xbb\x37\x4b\xc1\x3c\xde\xa1\x6a\x41\x65\xca\x82\x11\x4a\x80\x6d\x82\x0a\xab\x0f\xc7\x76\x82\x9b\x43\xeb\xdd\x75\x54\x7d\x2c\x43\x4e\xca\x9d\x70\x11\x42\xef\x67\xe8\xb4\xf6\x84\x05\x62\x93\xc7\xf2\xf4\x0e\x83\x69\x12\x36\x3b\x60\x59\xba\x15\x49\x73\xd8\x21\xbd\x12\x49\x5a\x07\x57\x97\xf1\x39\x77\x64\x1f\x1d\x20\x8b\xac\xb4\x3f\x10\x8e\xe5\x00\xc2\xaf\x4d\x8d\x79\x0b\x1d\xb7\x96\x4f\xa0\xe6\x7c\xd7\x65\x37\xa8\x89\x27\xf4\x2d\x3f\x5e\xe2\x3e\xf8\xae\xa1\xb4\x8f\x38\x63\x72\x5b\xad\x93\x1d\x4c\x19\x9d\x46\x19\x94\xd4\x76\xa6\x66\x16\x20\x37\x0d\x12\x94\x06\x9d\x32\x6c\xfc\x11\x55\x40\xd8\x77\x2b\xea\xed\x83\x11\x72\x57\x6a\xbf\x2e\x49\xbc\x81\x96\xab\x4e\x05\x96\x4b\x58\x50\xc3\x4e\x43\xd7\xb1\x9a\x93\x5c\x1f\x40\xbe\xe5\x9e\xab\xa0\x8b\x67\x15\xf4\x7a\x05\x01\x16\xce\xb0\x38\xf7\x8a\x6c\x95\x6c\x8d\x84\x8b\xe8\x98\x86\x1e\x30\x14\x20\xe8\xae\x47\xb1\x90\x36\x67\xb0\x83\x6f\xe5\xbc\xb4\x6a\x46\x02\xbd\x3b\xcc\x56\x5c\x9a\x03\x08\xc0\x28\x64\xeb\x04\xcc\x65\xb8\x01\x8a\x6b\x8b\x8a\x87\x57\x80\xf6\x83\x82\x18\xdd\x7a\xd7\xa7\x71\x55\xea\xc3\x1c\x8e\x34\x3c\x9f\xaf\x94\x8b\xa4\x9f\xdb\x12\x2e\xac\x46\x46\xe6\x43\x40\x89\xbf\x78\xcf\xb1\xfa\xef\xf6\x7c\x51\x59\xff\xf9\x81\xbd\x0d\x04\x69\x5f\x52\x81\x48\x7d\x40\x67\x52\xf0\x6e\xe0\x30\x51\xeb\xb8\x8e\xf0\xd2\xed\x80\xa1\x31\x39\xc7\x64\x84\x1b\x77\x1e\xa8\x9e\xa3\x36\x9e\x22\xa2\x55\x51\xd5\x1f\xa8\xcf\x71\x5a\xe2\x82\x4e\xd8\x71\x5a\xe3\x1c\xee\x3a\x77\xd4\x8a\x8b\x91\x5b\x0e\xd9\xa0\x55\x61\x92\x45\xc4\x0d\xce\xc6\xa4\xa7\xe0\xa1\x02\xab\x69\x42\x32\xe4\xf1\x30\x81\x31\x2f\xb6\xf3\xd1\x4a\xe5\x03\x7f\xc1\x5c\xbf\xcd\xa4\x0d\x77\xcb\xf5\x86\xf0\x9b\xab\xe1\x60\x5b\xd7\x09\x4e\x65\x26\x19\x91\x6c\xaf\xb1\xc4\x4e\x45\x85\xaa\x04\x22\xf9\x58\x75\xf0\x0d\x85\x6f\x45\x44\xab\xa8\xad\x5e\x3e\xc4\x81\xba\x98\xc3\x1d\xe3\x9d\x4b\x7f\x23\x52\x2a\x1a\xc2\xbc\x87\x64\x06\xa8\x13\x95\xaf\xf3\xfc\x85\xa5\x8a\x02\x94\x48\xe6\xad\x44\x58\x41\x6c\x30\x11\x6f\x43\xeb\x9d\xda\xaf\xd1\x49\x1f\xa3\x89\x9b\xce\x7a\x92\xc4\x33\x1c\xfc\xf2\x66\xfb\x19\xaf\xc9\x29\x11\x92\x6c\x4b\x0b\xbd\x7e\x15\x57\x99\x77\xec\x2e\x18\x20\x4e\x7b\xf4\x48\xda\x03\xa7\xeb\xba\xd8\xeb\xeb\x1e\xae\xf9\x73\x62\x25\xa3\x44\x5b\xa6\xa3\xf5\x72\x6c\xe3\xcd\xb1\xbc\xb3\xc1\x10\x65\x5b\xf7\x88\xa4\x9f\x7d\x5f\xd2\x25\x93\x3b\xc2\x5b\xc2\xdf\x91\x7c\x68\xcd\x40\xc9\xc0\xb3\x41\x6c\x1a\x72\x6a\x35\x8d\x8f\xa2\xed\x0c\x52\xde\xd3\x9e\xd5\xe5\x3d\x9c\xa9\xbe\xd5\xbb\x1a\xdc\xaf\xee\x46\xe9\xc4\x0e\x11\x14\x8b\x68\x89\x11\x1d\x5b\x09\xd7\xb7\x1c\x91\x56\x0a\x92\x4a\x75\xe0\x00\xfc\x92\x4c\x6d\xdc\x49\xa4\xe9\x19\x08\x08\x40\xb6\x7c\xf9\x88\x4d\x42\x1a\x0b\x98\x28\x94\xc1\xcc\x72\xc0\x06\xac\x04\x16\xfc\x6e\x1c\xb2\xf4\xfc\x63\x68\x40\xef\x62\xf6\xb7\x9a\xe8\xf3\x4b\x9f\x2e\x52\x9f\xb9\x1a\xe0\xc2\x35\xac\x7d\x46\xf5\x1d\x4d\x3d\x6c\xb9\x34\xf5\x70\x7a\x2e\xb1\x35\xba\x50\x7e\x93\x8d\x84\xe9\x76\xd9\x9d\x06\xd3\x9d\x07\x26\x71\x09\xe6\x86\x84\xe6\x95\x6c\x6f\x55\xbc\x3a\x9d\x6e\xc4\x97\x71\x12\xd5\x4d\x1b\x9c\xce\x79\x94\x1d\x33\xd2\xc6\x09\x43\x38\x62\x25\xd1\xdb\xcd\xde\x36\xbe\xe5\x35\x44\x45\x17\xf9\xb0\x38\xe9\xd4\x10\xca\xbe\x3a\x89\x51\xcb\x22\x6a\x1f\xeb\xed\x44\x68\x5a\xf4\x11\x42\x36\x18\x65\x99\xfe\xda\x3d\xbb\x7e\x6e\x41\xff\xb7\x8a\xba\xe1\x4f\xbb\xd9\x76\xbf\xee\x60\x87\x18\x07\xb1\xf4\x56\xd7\x89\xc7\x18\xaa\xc3\xd1\x4f\xe3\x1d\xca\x0e\x8d\x8e\x3c\xe3\x27\xc5\xc0\x56\x9a\xd1\xa0\xba\x8a\x3d\x6e\x82\x51\xac\x48\x26\x6c\x90\x02\xf1\x91\xc9\xb1\x0e\xa4\x28\xae\xee\xed\xcf\x97\x6f\xe1\x46\xc3\x3e\x4b\x08\x4c\xda\x0b\xa9\x5b\x4c\x1f\x90\xc6\x3d\xb3\x1e\x21\xda\xf1\x71\xcb\x31\xa4\x1d\xb8\xcc\x78\x36\x54\x99\xdd\x70\x61\xc9\x9b\xb9\x4c\x29\x90\xca\x42\xe3\x32\x32\xbc\xd8\x2f\x37\x52\xbb\x5a\x5e\x80\x37\x84\xde\x30\x08\x7b\x31\xaf\x81\xa3\x49\xe9\xf9\x52\xd3\xaa\xc6\x90\x28\x9d\x9e\x59\xff\x94\xb3\xf2\xd6\x8d\xdc\x53\xa0\x6b\x2b\xcd\x60\x6e\x07\x3d\x75\x73\x54\xa2\x1f\x0c\x93\xbb\x4a\x8b\xa9\x92\x5e\xa5\x26\x3f\x74\x9f\x43\x60\x14\x4f\xd9\x27\xbd\x5b\x9b\xea\xf3\xa9\xa7\x1c\xaa\x73\x79\x12\xa4\x37\xa3\x56\x74\x03\x04\x77\x70\xc4\x03\x78\x34\x90\xd3\xae\x0a\x29\x4c\xd2\xea\xa6\x5d\xb1\xe5\x4d\x83\x4c\x2f\x1e\xe8\x49\xc1\x62\x89\xe9\x38\x64\x00\x93\xb5\xbb\x26\x74\xdb\x08\xcb\xcb\x12\x8b\xf1\xb3\x57\x4f\xee\x9a\xa5\x9a\xa8\x8a\xe1\xa4\xc3\x47\x8d\x5d\xc1\x0b\x14\xd7\xba\x42\x1d\x5a\x12\xfc\x7a\x78\x6c\x2f\xa4\x85\x10\x34\x8d\x26\x32\x2b\x6e\xb2\x37\xea\x82\x69\x4e\x9b\x8f\xb5\x99\xe8\x4c\xc9\x6e\x1c\xc2\x08\xe5\xc7\x4a\xcb\x39\x17\x02\x73\xc2\xb5\x34\x90\xa3\xeb\x8d\x31\x0e\x53\x39\x8f\x57\x5a\x8e\x4f\x19\xb9\x48\xb2\xd2\x1f\xd6\x48\x49\x1b\x45\x4a\x76\xe2\xe2\x4e\x7a\x85\x78\xd7\xf2\xc7\x26\x34\xa4\x27\x16\x9c\x7b\x02\x21\xc8\x0f\x0f\x54\x73\x71\x87\x9c\x37\x08\x62\x86\xc7\xe5\xee\x9d\x95\x0f\x04\xaa\x4c\x14\xdf\x80\x62\x52\x0d\xdd\x4e\xda\xac\x99\x4e\xa4\x19\xe5\xe9\x05\x60\x9b\x9b\x8c\x56\x31\x3e\x11\xfa\xf9\x62\x18\xad\x0b\x15\x1e\x64\x1b\x82\x76\xaf\x4c\xae\x59\x4d\xb3\x21\x1e\x6c\xcc\x8e\xe1\x6a\xca\x78\xfa\x55\xe3\x97\xed\x44\x4e\xc6\xaa\xec\xe7\x08\xc6\x16\xcd\x2c\x23\x06\xf9\xb1\x20\x34\x9b\x88\x9c\x8c\xc8\x1a\x49\xb7\x72\x4b\x0e\xe8\xe1\x2d\xb1\x65\xc4\x7c\xc7\x4f\x26\xa5\x1d\x56\x5d\x1f\x1d\xc2\x60\x91\xdc\x84\x67\xdd\x68\x98\xc9\x3d\xc9\x9b\xf0\x10\x24\xe9\xa6\x36\xaa\xfb\x0a\x55\x5f\x23\x1f\x2c\x60\x5c\xa3\xd8\x5b\xcc\x70\xdd\x60\xb4\x48\x5a\x75\xe4\x40\x56\xe1\x72\x7d\x3a\x43\xd0\x7d\x45\xab\xbe\x48\x8c\xb0\x13\xef\x5a\xa6\x39\x88\x7f\x1b\xbe\x91\x3e\x0e\x95\x31\xca\x2d\x7d\xee\x2b\x8e\x19\x4f\xde\x46\x85\x57\x24\xd3\x37\x47\x2f\xf0\x60\x67\x2c\x24\xb7\x5c\xde\xc9\xf0\x4a\x93\x05\xf9\x85\x43\x37\xff\x25\x86\xa9\x50\xe4\xef\x60\x01\xfa\x81\x5e\xc3\x96\x6e\xe0\xb4\xd1\x85\x7d\x30\xe3\x55\x56\x00\x03\xd7\x61\x72\xdb\x65\x9d\xd6\x27\x83\x3b\x2b\xf4\x9d\xfb\xd4\x5f\x9a\x15\x9a\xfc\x6f\xf6\x6d\x5b\xed\xfc\x29\x29\x08\xbf\x3f\xea\x5b\xbc\x53\x22\xd3\x8c\x67\x03\xd3\x87\x2d\xa8\x69\xdf\x29\xef\xa9\x96\xd9\x26\xee\x22\x2b\xad\xa2\xf7\x41\x90\xdc\x03\x55\x51\x52\xe4\x98\x6b\xb0\x4b\x4b\xd3\x6b\xdf\xe4\x8c\xc3\xc6\xf2\x86\xef\x94\xe0\xc5\x2d\x8a\x38\xe8\xe1\x9b\xa5\x3d\x27\x2b\xe0\x32\x9f\x5c\x6c\x45\xd2\x69\x1b\xca\x6b\xde\x56\xea\xe7\xea\x64\xab\x51\xfb\x5a\x46\x23\x8d\xc8\xe1\x37\x16\x6b\x24\xa4\xc9\xbc\xc6\x57\xb5\x46\x23\x2b\xb0\x16\xc7\x20\x8d\xd6\xf0\x10\x43\x20\x5c\xb7\x9b\xf6\xdc\xf7\x62\x2c\x9d\x98\x39\x08\xab\x0c\x55\x70\x37\xe3\xb8\xce\xa3\xe3\xcc\x3b\x31\x80\x1e\x45\x36\x66\xab\x3e\x47\x79\xd7\xbf\x2c\x47\xb1\x0f\x41\x57\x2f\xd4\x39\x38\x76\x09\x4c\x74\x46\x8e\xde\x69\xc3\x89\x01\x85\xb8\xed\x6d\x8b\xe7\x99\xa6\x64\xeb\x5d\x65\x1d\x51\x3f\xb0\x55\x5b\x52\x75\x86\x2c\xac\x6c\x48\x59\xed\xc5\x14\x88\xbb\x48\x8f\xe2\xa5\xf7\x78\xae\x9f\xc7\x1d\x18\xf4\xa8\x66\x94\xfc\x75\xb8\x2a\xbe\xf5\xf9\x33\x45\x2d\xfe\xc9\x4e\x93\x7f\xca\xaf\x19\xd3\xf1\x5a\x84\x26\x98\xf5\xf7\x17\x0d\x52\x50\x2e\xe4\xb1\xf6\x00\xe6\xf6\xca\x23\x02\xe3\x1b\x5b\x9e\x5a\x99\x22\x08\x8a\xf5\x62\x07\x6d\x77\x8f\x79\xdc\xde\x84\x48\xef\x35\x48\x1f\x6c\xa3\xe1\x8a\xee\x01\x20\xba\xd9\x04\xb5\x92\xa9\x0c\x9b\x00\xa1\x5c\x15\x4e\x4d\xb8\x38\x91\xe5\x7e\xe6\x7e\x5a\x2f\xcc\x93\xe6\x6a\x49\xd5\x46\x15\x28\x83\xac\xd3\x8b\xc5\x31\x43\x79\x23\x41\xc3\x86\x67\xab\x1e\x73\x9a\x92\x96\x7d\xbc\x51\x75\x22\x82\xef\x18\xe7\x2e\x61\x57\xfa\x1b\x51\xd4\x33\x98\xcc\x8b\x7f\x92\xef\x62\xdd\x2d\x17\xd8\x0b\xa0\xac\x87\x06\xe9\xf6\x17\x7a\x79\x52\x13\xfa\x55\xf4\xbc\xf1\xab\x46\x0a\x9b\xb1\x09\x3d\xe6\x8c\xe8\x41\xbb\x24\xde\x9c\x32\xdc\xc5\xc8\x08\xea\x1b\x4a\x32\xe7\xdb\xb4\x87\x74\xcc\x8b\x86\x94\x41\x35\x6f\x11\x1f\x6b\x56\x1a\xa6\x0e\xba\xec\x55\xd6\x97\xde\xbc\x9c\x9e\x57\xbf\xa4\x95\x08\xf3\xa8\xbc\x77\x42\x6a\x57\x2e\x8b\xf7\xb1\x0c\x52\x8d\x01\x16\xa4\xbc\x60\xab\x11\x60\xa3\x88\xcd\x95\x52\xa8\x31\x0b\x8a\x64\x38\x79\x66\xb2\x31\xb2\x2b\x18\x3c\x73\x8c\xf3\x7a\x71\x88\x18\xa1\xdb\x83\x9b\xe7\xeb\x7a\xd1\x2b\xd8\x76\x8a\xcd\x95\x05\x2b\x66\x0c\x4e\x87\x15\x86\x3e\xe3\xcc\x9a\x6e\x86\x18\x58\x85\x57\xd1\x3c\xfd\xb2\x5f\x04\x68\x9d\x8b\xac\xfd\xc5\xcf\xe6\x37\xf3\xf4\xf7\x0a\xd8\xf6\x8f\xaf\xc7\xbb\x79\x79\xfb\x20\xef\x1f\x6f\xa0\xc3\x5e\x99\x72\x15\x56\xfc\x14\xbb\xe7\xec\x2b\x13\x0d\xbf\xa0\x49\x6b\xbd\xa2\x11\x1b\x99\xc5\xf2\x35\x92\xfa\x63\xa3\x18\xde\x7c\xbb\x8b\xb7\x31\xa3\xbd\x39\x6f\x97\x96\xe7\xb2\x65\xdf\xfd\xeb\x39\xfb\xce\x0b\xae\x59\xc5\xb0\x6f\x9e\xa1\x0d\xd8\x9a\x03\x07\xa2\x0f\x97\x52\x23\xe8\xc0\x19\xe3\xb6\x8d\xc6\x65\xf2\xa8\x28\x9a\xfb\x41\xde\x16\x2a\xb2\xbb\xc7\x08\x06\x3c\x18\x63\x00\x91\xdc\x3a\x69\xb8\x15\x9b\x59\x2f\x05\x62\x51\x39\x70\xec\x46\x52\x13\x63\x98\xea\xf1\x62\xf8\x43\x04\x08\xf9\x02\x6c\xbd\x41\x00\xa4\x82\xa5\x8e\x53\x9d\xd7\x40\x1e\xd7\xd3\xe1\x5a\x91\x87\xd3\x40\x42\x03\xef\x55\x8c\x93\x1f\x57\x40\xd4\xf1\xf5\x70\xde\xd8\x03\xe1\x6a\x1a\x5b\xf4\xab\x10\xa6\x7e\xab\x30\xfd\x40\x84\x83\x72\x07\x09\x54\xe4\x8a\xa0\x92\x09\x69\x51\x91\xe6\x74\x79\xea\x14\x4f\x5d\xda\xec\x41\xab\x91\x8f\xc6\x00\x6c\x6c\xee\xe3\x94\x08\xcc\x13\xcc\x23\xa5\xd8\xe1\x0d\x46\x63\x6f\x7d\x58\x5d\x9a\x36\xbe\x1b\x3a\x37\x4f\x42\x84\xd3\x7c\xff\xb2\x7b\x23\x80\xd4\xd9\x5c\x8d\xdd\x05\x68\x51\x68\x79\x5f\xe6\xea\x61\xc4\x6e\x00\xa7\xeb\x10\x0e\x50\x4d\xc5\x4c\x3b\x7d\x09\xaa\x3c\xef\x96\xf2\xc6\xf5\xb6\x3f\x04\x0b\x99\x03\x10\xad\x52\x8b\x70\x2e\xdd\x2a\xf1\x63\x0b\x75\xa8\x32\x7c\x46\x87\x7d\x35\xee\x99\x74\x45\xec\xaa\x16\x9f\x75\x05\x53\x0a\x52\x71\xbd\xa6\x35\x7d\x68\x14\x1c\x52\x75\x9b\x2c\x73\x4e\xcd\x51\xa7\x58\xc2\x03\x1b\x80\x01\x2a\x09\xd1\xca\x1e\x1e\xc6\xf5\x1b\xc9\x5d\xc8\x2c\x77\xf4\x0c\x22\x42\xda\x73\x07\xa3\xdb\xee\x42\x31\x0e\xa3\xd7\xc6\x98\xaf\x26\x51\x9c\x3e\x4c\xe6\xd4\x32\x3e\x48\x16\xb0\xc1\x64\x71\x50\x51\x1e\x4a\xdb\x6d\x49\xda\xd2\x1c\x89\x20\x60\x26\xcc\xab\x46\x30\xb9\xc7\x83\xdd\x80\x85\x94\xa8\xc5\x04\x37\xc4\x69\x03\x22\x78\x75\x65\x19\x69\xfd\xc5\x3d\xb6\xb8\x6d\x49\x72\x8d\xea\x1e\x55\x76\x79\x7e\xc7\xc7\xa0\xc5\x80\x0e\x55\x71\xde\xcb\x9b\xc8\x53\x6d\xf2\x30\xac\xb7\xcb\x72\x08\x60\x57\xda\x59\x86\x1e\xcd\x05\xf8\x1e\x52\xf4\xfb\x94\x73\xb6\x63\xc0\x15\xa2\x5f\xc0\xc4\x5a\xeb\xd0\xaf\x8f\x49\x20\xe0\x4d\xae\xcb\x54\xe3\xde\xe8\xce\x6a\xb2\xf9\x7a\xc7\xa3\xaf\xd1\x10\x6a\xb9\xd3\xeb\xe9\x2a\x3c\xed\x37\x7d\xf2\xe6\x08\xc2\xdd\x10\x4d\xbd\xe5\x32\x78\x63\x4a\x32\xa7\xb3\x6c\xa0\xcd\xf7\x94\x81\x69\xb5\x70\x28\x05\x69\xf1\xa3\x9b\x5e\xdb\x78\x26\xda\x1c\x3a\x1d\x0d\x54\xdd\x4e\x33\x1a\xea\x22\x1a\x41\x46\xf1\xf9\x97\x8e\xc8\x6d\xba\xa5\x7f\xb3\x08\xff\x6d\x3b\x9b\x27\xe9\x83\xdf\xb3\xe3\xd1\x68\x4c\xfe\x2c\x9f\xf6\x59\xdb\x53\xe6\x30\x6e\x1f\xc8\x93\xc3\x32\xbc\xe5\xd1\xad\x3d\xbb\xfc\x58\xf2\x37\x7a\x24\x05\xfd\x13\xe9\x9a\x31\xd9\xc5\x2a\xd3\x3c\xf2\x9a\x9e\xaa\xa1\xd0\xb2\xfc\x7c\xd2\x70\xfb\x36\x1d\x0a\x49\x53\x1c\x30\xc8\x33\x59\xfd\xe3\x3c\xba\x77\xf4\x46\x1e\x8f\xe1\xca\xaf\xcc\xb3\x1d\xa6\x92\x58\x12\x19\x5b\x24\x4f\x61\xb2\xe0\x10\x7c\x3c\xf0\xc7\x36\x5e\x6f\xc3\x78\x17\x4f\x74\x6a\xb2\xd3\x1f\xca\x93\x7a\x58\x4c\x79\xf1\x55\x18\x08\x6b\xac\x15\xe7\xd6\x5b\x62\xaa\xc7\xe8\xa3\x87\x52\xc7\xbd\x51\xcf\x97\x85\xf1\x3d\xdd\x0d\xf9\xd8\x8d\xce\xbe\x9a\x37\xe3\x5c\xb0\x15\xe0\xbd\xf8\x71\xb6\x54\xf8\x7e\x26\xe3\xf0\x3c\x46\x18\x30\x3b\xc8\xdd\x47\x40\xdc\x96\x51\xc2\x3a\xd4\xd3\xd6\x12\xed\x8c\xc7\x31\x09\xd3\xf3\xed\xd8\x1b\xe4\x5d\x66\x46\xe6\xb4\xbc\x22\xb7\x84\x23\x26\x0e\x90\x06\x22\x5a\x8f\xeb\xe5\xf8\x06\xb7\x14\xdd\xaa\x35\xde\x10\x62\x8b\x70\xe4\x25\x13\xf5\x63\x54\xd9\x1e\x6d\x3a\xae\xbe\xc0\x93\x58\x5e\xbe\xa2\x28\x6f\x95\x2a\x84\xb0\xe0\x25\x42\xee\xd0\x82\x81\x29\xad\xe1\xdd\xd2\xe7\x95\xa8\x20\x80\x82\xf6\x10\xed\x06\x35\x5b\xcf\x4a\x6f\xd2\xe0\xaf\x75\x89\x3c\x66\xcb\x14\xcb\x72\x0b\x13\xa0\x25\x6c\x3f\x67\xb6\xde\x75\x00\x92\x2e\x56\xec\x07\xfa\x32\xdf\xea\xb1\xc2\x25\xbb\x16\x78\x02\x2b\x5d\x09\xeb\xbb\x57\x3f\xfd\x48\xc3\x8d\x11\x4e\xe8\x40\xf0\x7a\x63\x27\xc0\x4c\x05\x1b\x67\x14\xe9\x17\xf5\xda\xa5\xc5\x1c\x3c\xe7\x39\x1f\x90\x31\x4b\xa7\xea\x04\xa3\x61\x8d\x93\x3e\xa9\x54\x97\xc3\x4c\x9b\x71\xe8\xd6\x61\x8a\x18\x60\x46\xc7\x4c\xbc\xa5\xa3\x82\x30\xb2\x4b\xa9\x08\xa1\xe9\xa2\xe3\x22\xf1\x8f\x67\x6d\x9f\x6a\x2a\x78\xa1\xa0\xed\x04\x88\xd2\x0a\x8c\x27\xc2\x01\x24\x3c\xdf\x20\xf1\x19\x83\x26\xc4\x0d\x6f\x94\x57\x3d\x5f\xa2\xc9\xda\x1f\x5d\x7c\x6e\x64\x90\xe3\x25\x2d\x9e\xaa\x5b\x06\x93\x0e\xeb\xac\x46\xe4\x00\x8d\xed\x3f\x2d\x9f\xb7\x6f\x46\x50\x2f\xb8\x36\x15\x63\x7b\xdc\xc4\x28\xae\x38\x57\x70\xc6\x17\x45\xf0\x05\xfc\x8c\xdc\x3e\xaa\x7d\xb7\x14\xeb\x23\xce\xb1\x59\xed\x8d\x48\xc7\x38\x51\x73\x60\x4f\xdf\x1f\x49\x60\xd1\x72\x73\x9b\x16\xd1\x08\x4f\xe8\xc1\x27\xbe\x5a\x4e\xe8\x2b\x47\xcf\x59\xbe\x09\x64\xd0\xcd\x9a\xac\x3c\xe2\x9c\xa3\xec\xb8\x62\x00\xce\xb0\xf4\xe7\x12\x32\xfd\x3c\x32\xb2\x4b\xe2\xc7\xc0\xe9\x1e\x33\x01\x56\x58\x80\x1a\x83\x07\xc9\xa3\xe0\x33\xc5\xfb\xde\x45\x97\xc6\x24\xf9\xea\x37\xaa\x58\xfe\xda\x45\x2c\xed\xb3\xfa\x9f\x5f\xbf\x15\xcb\xbf\xd9\x3a\xfc\x3f\x56\xbc\xcd\x3e\xd9\xaf\x3f\xb7\xb6\x9b\xd1\x62\xd0\x9f\x5d\x78\x38\xd3\x53\x54\x0c\x23\x6b\xf6\xba\x83\x16\x79\xc9\xc4\x25\x92\xde\x60\x9d\xef\xc3\x56\x99\x45\xd8\x17\x38\xb3\xa2\xf9\x14\xad\xc3\xe2\xf0\x3c\x92\xa8\x2b\x29\x54\x66\xcf\x42\x9d\x3c\x45\x0b\x8b\xb4\xd6\xa3\xc8\x01\xd2\xf2\xe5\xe7\xd5\x31\x3a\xb1\x3f\x6e\x0f\xa0\x9e\x97\x19\x46\xe3\xfc\x5a\xcb\xb7\xe8\xe7\xe0\x30\x31\x7d\xec\xd1\x31\x7d\x6b\xc8\x39\x2b\xa2\x85\xbe\x5a\xd9\x73\x96\x17\x42\x75\x6f\x02\x99\x01\xf1\x4d\x71\x9e\x1f\x5b\x66\x99\x0e\xfb\x16\x8f\x52\xf1\x2e\x1c\xd0\x1d\xb9\x32\x5b\xd9\x6c\xde\x15\xf1\xf5\x8c\x6e\xfe\x83\x82\xa5\xd7\x40\xd4\x97\x40\x8b\x00\xea\x55\xc6\x1b\x5a\xd9\x9d\x57\xc0\xe5\x9d\x33\x2c\xe9\x83\x6a\x06\x01\x96\xdd\x49\x0b\xa5\x1c\xae\x36\x6a\xb8\xc7\xdc\x62\xf8\xa2\x65\xdd\x54\x18\x51\x8b\x86\x65\xce\x78\x3a\x66\xe6\x83\x94\xc6\x17\x2b\xaa\x81\x9b\xd3\x11\xb9\x4a\x0f\x8c\x7f\xbe\x06\x31\xda\x20\x32\x30\xf1\x80\xe3\x4b\xd0\x8a\x66\x95\x66\x0c\xf2\x46\xd3\x55\x93\x66\x43\x2c\x18\x86\xe2\x71\x36\xec\xf8\x42\x4e\xde\x12\x4a\x04\x4d\xcb\x41\x2d\x35\xde\x37\x35\x7d\x37\xa0\x4e\x57\x4d\x0c\x98\xb6\xc8\xd2\x69\x5b\xeb\x86\x83\x8e\x5c\xa2\xa7\xf2\xf8\x56\x19\xb1\x27\x40\xd7\xd2\xdd\x3c\xef\x20\xc3\x16\x91\x08\x60\xe9\x50\xe3\x11\xa0\xa0\xc3\x00\xab\x1d\x27\x90\x95\xc3\x0c\x8d\x6e\x7e\x5b\x10\x35\x0b\x95\xfe\x7a\xd1\x65\xe6\x8b\xb1\xa4\xcb\xf8\x52\xbe\x40\x9a\x9a\xbc\x80\xae\x5f\x2b\x3c\x3f\xb2\x38\x6e\x67\x8d\xe8\xd9\x04\xc1\x49\xa4\xa2\x09\xd0\x43\x3c\x95\x00\x18\x94\x31\x26\x13\x84\x41\x71\x67\x28\xef\xb9\x3f\xe8\x8b\xd4\x2a\x7d\x09\x47\xc0\xe8\x02\x92\x97\xaa\x89\x21\xa1\x9c\x18\xe3\x9d\x3d\x99\xa4\xe7\x83\x4e\xca\x5f\xba\xa7\x0a\x63\x37\x94\xb5\xe2\x99\xd6\xc6\x3f\xd8\x51\x6d\xc0\x07\x7d\xd2\x9c\xa2\x3e\x22\x16\xa8\x49\xc4\x4b\x13\x4f\x69\xd3\x14\xeb\x69\x43\x7b\x9a\xc2\x8b\x8e\x96\x9e\xa7\xa7\x37\xbd\x9b\xd4\x8a\xcd\xa7\x87\xf9\x87\xf6\xf0\xc1\x12\x99\x20\x41\x5f\xa1\x03\x5d\x09\x93\x8b\x5f\x20\xcc\xa8\xb4\x4e\x07\xee\xdb\x35\xb4\xb7\x0a\xe9\xb5\x66\xb5\xe4\x60\x08\xe0\x26\x0c\x37\x16\x4a\xb6\x5d\x65\xf6\x28\xe2\x51\x5a\x1c\xa1\x90\xa6\xdd\xf4\xe2\xdd\xdd\x0f\x11\xe6\xf2\x5d\xbd\x54\xe0\x09\xa2\x5f\xe8\x6c\xad\xef\xcd\x8e\x5d\x47\xdb\xfb\xda\x71\xf0\xc1\x4d\xe3\xb3\x01\xc3\xfe\x49\x2b\x6f\xc1\x39\x90\x69\xad\x31\xa0\xd7\x17\xac\xdf\x48\x46\xdb\xa3\x27\xa8\xa3\xbd\xfb\x8c\x35\x88\x28\xe1\x55\xc5\x76\x0b\xef\x5b\x20\x87\x13\x6b\x84\x1d\xf9\x16\x7b\xe4\x83\xdb\x5e\xd3\x59\x56\x81\x76\x3e\x44\xac\x63\xd4\xd4\xb6\xcd\xc7\x26\xc0\x4f\x2d\xbf\x35\x0f\x9a\x66\x1a\x5b\x42\x2c\x3e\x87\x1a\xe0\xaf\x4d\x16\x7f\xb3\x39\xfa\xa9\x3c\x03\xa1\x06\x43\x1e\xd2\xcd\xc1\xd8\x32\x17\xab\xbf\xeb\x63\x68\x16\xd1\xdf\xff\xb8\x1d\x28\x25\xa6\x8e\xe1\xa5\x2f\x58\xa6\x49\xc2\xe2\x99\xb5\x60\x43\x10\x2b\x20\x37\xcc\x33\xe1\xc0\x26\xb8\x02\x43\xe7\xa1\xdd\x86\x83\x29\xf5\x6b\x3c\x1f\x02\xaf\xec\x30\x3f\x46\x9e\xef\xf8\xea\x3b\xb9\x25\x6f\x32\x77\xa0\xe6\x58\x2f\xb9\x08\xf5\x85\xc8\x57\xa5\x08\xcd\xd9\xa8\xe3\x25\x07\x36\x71\xe8\x6c\xf1\xe0\xe3\x9f\xf7\x59\x18\x80\xb1\x4b\x36\xb2\x54\xe1\xa5\x08\xed\x85\x38\x53\x72\x27\x74\x19\xac\xf4\xb2\x50\x1b\x3e\xcb\x70\x19\xa2\xf4\x32\xe7\xaf\xfa\x09\xb5\x3a\xc7\x1f\x32\x17\xc3\x5a\xcb\x83\x86\x17\xc3\xba\xbb\x57\x7a\x4b\x1f\x7a\x43\xee\x9f\x3f\xa3\x01\x0f\x83\x9b\x20\xa3\x9d\x4e\xe3\xa4\x2b\x99\xfd\xf5\xd7\xa2\x95\x25\x29\x5d\xd2\x3e\x5d\x87\x8f\x7f\xb7\x27\x1f\x9c\xc1\x72\x95\xa9\x90\x9c\xdd\x6c\xc8\xad\x40\x0a\x44\x1b\xf3\x4b\x1b\xa8\x33\x39\xc9\xc3\xf4\x3a\x4c\xbb\xe8\x53\xbb\xe4\x53\x8b\x94\x2e\x69\xa0\xab\x0c\x31\x30\x8e\xaa\x25\x1b\xf5\xf6\x4f\x7a\xf9\x24\x32\xda\x7c\xe8\xf7\x42\xec\xb7\xac\x61\xce\x44\x8c\xf1\x38\x54\xb6\x22\xb2\x29\xb9\x91\xff\xf0\x81\x08\xed\x7f\xbe\x66\x36\xea\xeb\x2f\x9f\xac\x31\x4c\x2d\x1a\x52\xd7\x39\x4b\x1e\x5a\x4b\x6f\x72\xc3\xa0\x59\x78\xac\xf9\xf5\x44\xb3\x88\x31\x3c\x0f\x6c\x52\xc9\x01\x73\x6e\xda\x34\x18\xbb\xb4\xe1\xdb\x57\xda\xcf\xfe\xa4\xd0\x38\xa2\x37\xdd\x45\x77\x0d\x86\x16\xed\xfc\xe3\x9a\x39\xe2\xb8\x49\x18\x53\xf2\x50\x83\x85\x44\xe3\xda\x49\xad\xf9\xf9\x7b\xff\xb7\x19\x0c\x6e\xa5\x28\xec\xda\xc5\xaf\x3a\x4b\x5d\x81\xd4\xef\x89\x4b\xb9\x49\x64\x6c\x45\xa4\xb4\x1f\x2e\x25\x8d\xde\xc8\x52\xbd\xe4\xdc\x93\xcb\x87\xa0\x2e\x44\xea\x0c\x44\x6a\xcb\x38\xb0\xb1\xbf\xed\xaf\x7c\xb1\xde\x0a\x91\xba\x52\x91\xda\x65\xde\xf0\x8c\x86\x9e\x02\xb8\x5f\x13\x91\x42\xf2\xb3\xfb\x3e\x9f\x87\x0c\xb3\xeb\xd7\x1c\x71\xea\x6c\x30\x7a\xd7\xb7\x29\xf9\xc3\x15\x16\x7b\xa6\xa1\x8d\x3b\xbe\x8d\x99\x5c\x8c\xd9\xa0\x21\xea\x1e\x8f\xea\x9e\x20\xe8\x5e\xcf\x39\x6d\xcf\x19\x60\xc0\xd8\x5e\x8c\xd8\x5e\x07\xea\x1e\xff\x27\x7d\xce\x16\x23\xc1\x92\x84\x18\xf8\x27\x7d\xdd\xff\xaa\xcf\xf9\x2f\xf5\x59\x0d\x4d\x7e\xfa\xc7\xf3\x41\xdc\x11\x83\x33\x8d\x92\x3e\xe1\x93\x33\x83\xc1\xea\x97\x0f\xf1\x34\xc4\xae\x42\x14\xd6\x18\x0e\x14\x87\x03\x9b\x4f\x7d\x6d\xe8\x9f\x09\xf7\x14\x1c\xae\x43\x8d\xb6\xe7\x6c\x3f\x3e\x74\xaf\x3a\x74\xdf\x3f\x4c\xdf\x10\x4d\x5f\x47\x1c\x5f\x60\x8c\xb6\x60\x4c\xcf\x3e\x74\x57\xfe\x5d\x5f\x22\x52\x6d\x11\x42\x7d\x36\x3a\x7f\xd2\xe7\xfc\xaf\xfa\xba\xff\x52\xdf\xf6\xb1\x5d\x43\xfe\x09\x17\x3f\x1c\x65\xa9\x9f\x7c\xf4\x3b\x47\xfc\xae\xf7\x1d\x6f\x3f\xe3\xcf\x43\x2b\x8b\xa3\xd0\x5c\x14\xda\x14\x0e\x40\x59\x0c\xd6\x4f\x9c\xe7\x8d\x0c\x58\x93\x47\x5e\x36\x49\xd3\xb4\x52\xb8\xbe\xc3\x04\x52\x9b\x16\x82\x91\x79\x87\xe1\xf0\x16\x06\x2f\x84\x0b\x66\xdd\x92\xa9\x02\xbd\x79\x7e\x90\xee\x38\x18\xbf\x3a\xfe\xf0\x3d\x0e\x9f\x38\x02\x7d\xb1\xc0\xc9\x01\xfb\x13\xa8\x6a\x92\xc4\x22\x9e\x97\x41\x87\x3e\x63\xdb\x6f\xf4\xa7\xcc\x88\x7a\x17\x3b\xf8\x04\x23\x69\xd6\xdc\x08\xa4\x84\xd7\x1c\x44\x37\x48\x73\x4c\x7d\x19\x13\xcb\xb3\x1e\x8f\xcd\x32\x24\x5d\x3c\x35\x8e\x21\xe6\x4c\x81\xf3\xc6\x77\xfb\x06\xf1\x11\x6c\x1e\x3a\x95\x5a\x88\x83\xda\x88\x11\x2e\x38\xa0\x22\x55\xbf\xf3\xf7\xf0\x55\x5a\xc8\xa6\x5e\x30\x62\x1c\x8a\x78\x55\xbb\x79\x80\x0e\x8b\x0f\x6e\x25\x4f\xb7\x50\x5d\x37\x0b\xc3\xf5\xd2\xbf\x4e\x78\x54\xf8\x8e\xb4\xc2\x59\x54\x82\xc0\x5b\xeb\x30\x7b\x56\x83\xb4\xa3\x84\xc0\x10\x05\x45\x86\x15\x3a\x04\xa1\x8a\xc1\x13\x34\x1f\x66\x85\x04\x29\x62\x0d\xc2\xf3\x66\xc3\x56\xe1\xbf\xd6\x54\xf0\x75\x0a\xd8\xf6\x9b\x89\xe7\x16\x92\x1d\xfb\x80\xe2\xd1\x5e\x43\xb4\xe6\x20\xc0\xa6\x41\xe5\xad\x16\xdb\x3c\xa7\xba\xc9\xcd\xfd\xd9\x73\x5f\x48\x3e\x05\x9c\x3d\x47\x0a\xb2\x5f\x13\x26\xf1\x33\x92\xf7\x55\x62\xe8\x5e\x50\x1c\x90\x07\xf2\x4f\x22\x1f\x71\x00\xb0\x1d\x7b\xd7\xeb\x8b\xc6\xd7\x44\xd2\x38\x2c\x97\x05\x5e\x70\x55\xd9\xbf\x89\xa4\xa6\xde\x96\x0c\x54\x67\x31\x51\x73\x4f\x99\xf8\xd3\x02\x49\x3a\x7b\xe6\xda\x89\xcf\x99\xa5\x16\xf6\xbb\xa9\x0a\x5a\x4c\xb9\x3d\x3c\x66\x4e\x82\x56\x31\xeb\x1b\x36\x96\xab\x5c\x27\x43\xc1\xaa\x48\xfd\x85\x59\xed\x55\x9c\x2b\xda\xc6\x19\xcb\xa3\x28\x5f\x3e\x23\x5d\x5a\xf7\xa8\xbc\xd1\xe4\x81\xa8\x6a\x7c\xc4\x73\xbb\x65\xfe\x35\xf4\x96\xf8\x64\x86\xb8\xa8\x64\x68\x8a\x5b\x57\xcf\x34\x94\x9e\xa0\x38\xd2\xbb\x5c\x87\xb9\x02\x3e\xc6\x8c\x4e\x07\xcb\xa6\x5f\x15\x24\x9a\x8e\x96\x14\x67\x3e\xc4\x5e\xa1\xbc\x04\xb5\x83\x39\xcb\x41\x1e\xc3\x2e\xa3\x17\xc3\xbd\x2b\xca\xa1\xb9\xd7\x61\xd1\x99\xc5\x34\x0f\x38\xf4\x5c\x06\x23\x51\x00\x01\x3c\xb1\xac\x78\xb3\x59\x6e\x9c\x93\x6f\x36\x6a\x26\x4a\x03\x69\xd5\x2e\xdb\x6a\xc0\x56\x70\x83\x8f\x19\x24\x13\x12\xc2\xbc\x11\x3b\x7c\x79\xd4\x93\xa1\x2d\x6a\xe5\x62\xec\x68\x0b\x57\x47\x9c\xd7\x51\x4e\x7e\xf7\x08\x46\xde\x0c\x49\xbf\xd3\xce\x8e\x77\x3c\x23\x6a\x3b\x9d\xa8\x11\x79\xc7\x0d\x63\x93\x76\x5c\x69\xd7\x9a\xae\x83\x77\x96\x82\x37\xbb\xa4\xb5\xe9\xca\x65\x6a\xb4\x1d\x30\xd8\x8c\x43\xc9\x81\x64\x38\x58\x43\xdc\x64\xc6\xce\x9f\x9c\x88\xaf\x05\x0d\xc3\xdd\x19\xc2\x94\xc4\x12\xf0\xbe\x92\xa7\x88\x11\x54\x32\x35\x6e\xbc\x3a\x40\x7f\xc2\xb7\x93\x62\x69\xd4\xc8\xcb\x50\x1b\x26\x02\x22\x3c\xa8\xc1\x7c\xed\xa5\x18\x4b\xfa\xd4\x48\x96\xa3\xd9\xb9\x3b\x2c\x21\x71\x0e\x6d\xff\xab\x1f\xb1\xe9\xca\xf3\xef\x75\x43\xd1\x27\x7f\x4c\x38\xa0\xdf\x16\xbc\xea\xc4\x0a\xc0\xf4\xa2\xf8\xa1\x8f\xbf\x9a\xc6\x8d\xe3\x09\xe3\x87\xc1\xe2\x58\x8e\xa2\x25\x14\x9f\x0f\x32\xe7\xc7\x36\x05\x6e\x2c\x43\x91\xd4\x75\x8b\x6f\xba\x6a\x55\x7a\xc3\xcd\xb1\x4d\xb3\x79\x96\x86\x0c\x33\x55\x31\x47\xc1\x0b\x9c\xac\x05\x91\xf4\x76\x32\x67\x97\x9a\x20\x59\x8f\x5c\x2d\x32\x22\xf2\x5e\xc9\x4b\x1b\x97\x9c\x89\xe8\x7d\x38\x94\x60\xd6\xfa\x4b\x4d\x96\x24\xf0\x30\xe1\x45\xba\x0e\x24\x7a\xf9\x7c\x87\x81\xeb\x63\xb9\x19\xc5\x58\x17\x43\x8e\xb8\xfd\xc3\xb0\xba\x20\xf1\x48\xf6\xc4\x41\x90\x9b\x64\xd9\xdd\x82\x87\x1a\x2f\xfd\xf6\x88\xa0\x27\x8e\x47\xc3\x24\xc7\xb3\x9e\x14\xad\x62\x87\x1b\x2f\x64\xd9\xcc\x02\x2e\x56\xc1\x76\xed\x76\xaa\xaf\x12\xef\x03\x37\xaf\xed\x7a\x69\xcf\x79\xda\xe8\x3a\xa5\x0f\x1a\xe1\x7c\xc6\x1e\x61\xcf\x17\xe6\x9e\x50\x77\xef\x31\xa0\x09\xc5\x4d\x26\xa6\x85\xc4\x6a\x45\x0d\x15\x1e\xcf\xc7\x48\x24\xaa\x00\x52\xdb\x69\x1d\x11\xdc\x84\xb9\xe1\x74\xaa\x98\x5c\xe0\x60\x87\xea\x64\xcc\x24\x1d\x30\xf8\x01\x9d\x4e\x0c\x3f\xe3\x31\x87\x35\x6d\x7a\xac\x91\x77\xe8\x15\xdd\x0f\x7d\x24\x3f\xc6\x8a\x3d\x8c\x83\xbf\xf4\x1b\x67\x6d\xb8\x61\xa7\x30\x73\x56\x5a\x95\x9c\x11\xae\x78\x24\x32\x56\x92\x67\x60\x22\xad\x81\xa1\x3b\xf9\x76\xe7\xda\x63\xd4\x9d\x4c\x0d\x74\xa0\x58\x56\x1e\x9d\xf6\x85\x0e\x83\xb3\xa7\x6e\xe5\x72\x3b\xcf\x5a\x4e\xe8\x27\xcf\xa6\x83\x06\xb6\xbe\x5b\x22\x93\xc0\xd6\x07\xe2\x4d\x4f\x1d\xf5\x4a\xde\xb6\xe0\x2a\xc7\x99\x4a\x94\xf7\x0c\x55\x45\x23\x72\x6a\xb6\xd3\xc5\xa3\xaa\xe0\x4e\x29\xcf\xcc\x69\x12\x1d\xc5\x38\x32\xc4\xa1\x17\x4f\x77\xa3\x3b\x3c\x25\x77\x61\xea\x73\x5f\xc1\x51\x08\xd6\xa7\xcb\x7a\x74\xae\xa3\x3c\xbb\xbf\xd2\xe7\x76\x33\x6c\x5c\x73\x29\x45\xa4\xb5\x49\x97\xe5\xc9\x8a\xb9\x36\x69\x78\x0d\x3a\xa4\x25\x3b\x4d\x84\xa2\x6d\x9f\x4b\x69\xc2\x81\x68\x09\x46\x38\xb7\x74\x69\xb4\xde\x30\x47\x04\x02\xba\x3e\xa6\xc1\x8a\x2d\x72\xde\x29\x1a\xf5\x52\x96\x6a\xa4\xae\xf5\xc3\xe1\xbd\x88\x5b\x76\xb2\x10\xc9\x68\x25\x22\x5a\xe0\x80\x84\x21\x2a\x63\x35\xcf\xf0\xa3\x25\xbb\x4b\x74\x9d\xab\x20\x1f\x19\xca\x77\x3a\xaf\x10\x94\x9d\x02\x87\x94\xa9\x07\x5b\xe8\xc4\x51\xb2\xfb\xe5\x27\x66\x5b\xf1\xfb\xb8\x5e\x0b\xf1\xd2\x2e\xdc\x43\xf2\xd3\x1d\x6c\x0b\x45\xd6\xab\x2d\xe5\xc6\x53\x74\xbc\x99\xf0\x10\xa2\x18\xc0\xd0\x58\x55\x0f\x44\xf6\xea\xd8\x49\x73\x00\xb0\x7f\x3f\x4c\x19\x7e\x18\x27\x50\xaf\x2a\x0b\x09\xde\xac\x02\xef\x4c\x34\x4a\xdd\x61\xc9\x42\x7a\x4a\xcc\xf9\x58\x6f\x1b\x4d\xeb\xb4\x06\x80\xed\x46\x07\x89\xdd\xff\xc5\x5f\x26\xf4\xe5\xdf\x6d\x93\xd1\xff\x33\xb5\xf8\x3f\x53\x8b\xff\x2f\x4c\x2d\xda\x84\xff\xfc\x19\x9e\xf2\xc7\x54\xc0\x97\x77\x93\x0f\x78\xa7\xb5\x31\xdd\x4b\x78\xbd\x0b\x18\x87\xf7\xff\x7b\x53\x8b\xdf\xf5\x19\xff\xa5\xbe\xff\xcd\xa9\x85\x68\x74\x8e\x68\x74\x36\xa4\xf3\x7f\x4c\x05\xec\x96\x46\x1d\xdf\x11\x0d\xae\x3b\x8c\xce\x3e\x1d\x5f\xe0\x9d\xff\xde\xd4\xe2\x0f\x7d\xfe\x7f\xa9\xef\xff\x99\xa9\x45\x0f\xed\x14\x21\x7f\xa6\x16\xf5\x6f\x53\x8b\x5a\x31\xb4\xec\x50\x1c\x41\x7f\x00\xbb\x45\xcb\xba\x7c\xe8\x9d\x2f\x13\x8b\x0b\x06\xf1\xab\x17\x39\x4d\xac\xdb\x42\xed\x5e\x67\x02\xa3\xb9\x22\x18\x14\x8c\x15\xe5\x2d\xca\x4d\x43\x4a\x25\xa7\x45\x3b\xc2\x33\x38\xdc\x15\x27\x28\x08\xf7\xe1\x09\x77\xae\x56\xf7\x2f\x9d\xcb\x6c\x92\xa8\x2e\x2b\xce\x63\xa2\x43\xc5\x6a\x52\xf0\x6c\x28\x76\x8c\x22\xaf\x6d\xdc\x74\x80\xc2\x9e\x7e\x10\x07\x43\x7a\x9b\xb7\x7c\xda\x0e\xf2\xd4\x47\x21\x91\x68\x5d\xb1\x14\x46\x79\x70\xd7\x0b\xdb\x9e\x11\x7e\x03\x36\x0e\x7b\x4d\xc0\x45\x70\xa6\xce\x14\x13\x50\xc0\xf8\x82\xb7\x82\xae\x20\x4d\x8c\x41\x2d\x73\xa1\xfa\x4d\xb3\xf0\xfd\xe0\x77\x14\x14\x4f\x18\x79\xc5\x17\x83\x48\x26\xf1\x78\x0e\xcf\x84\x35\x87\x07\xff\x48\x89\x28\x43\x8d\xc3\x7c\xb3\x68\xbf\x65\x96\x37\x95\xf0\xa9\xf2\x88\x0a\x59\x85\xb5\x1b\xe6\x22\x15\x07\x41\xf1\xee\xe3\x85\xbe\xd4\xae\x69\x19\x0c\x88\xaa\x72\x93\x4f\xe9\xe0\x59\x18\xf5\xdd\xa1\xdc\xb9\x17\x07\xd3\xcc\xb1\x66\xa9\xe6\x74\x8f\x10\xbf\xf4\x57\x1b\x8a\x7d\x4d\x00\xcc\x79\xd2\xcb\x11\x8f\xa6\x35\x6a\xa0\x0d\xdf\x2a\x51\x1c\x54\x27\xdd\xc9\xcb\x67\x94\xd4\x6b\x5c\xcc\x36\x4d\x48\x50\xc6\x55\xa6\x75\xb2\xce\x9b\x54\x0e\xa5\xaa\x21\x8d\xdc\x35\x96\x5b\x3f\x05\x5c\x4c\x2a\x4c\x54\xc3\x53\xab\xd0\x0e\x24\x65\x9e\x6b\x08\xba\xff\x0c\x48\xee\xc8\xdb\x0a\x1c\xdd\x98\x79\x2f\xcc\x51\x68\xd9\x4b\x86\x9a\xba\x64\xfd\x9a\x8a\x22\x43\x5c\xdf\xf4\xce\x16\x7c\x97\x51\xf6\xc9\xb8\x42\x3a\x50\x1e\xf7\x98\xac\x04\xd2\xfc\x0a\x62\x24\x98\x94\x9b\x9d\xa7\x1d\x2f\xa0\x6d\xf3\xca\x05\xd5\x49\xa5\xe4\xa9\x4d\x29\x95\x6e\x31\xae\x41\xe2\x63\x06\x73\x04\x5e\x50\xcb\xc7\x43\xb8\x0f\xe7\x80\xd4\xe8\xe9\xbd\x83\xec\x0c\x8d\xd1\x63\x89\x43\x1e\x79\x25\xe2\x6b\x0f\xa5\x2b\x7e\xc2\xd7\xd5\x57\xe5\xb2\x4e\x7d\x20\x6c\x4b\xc3\x69\x99\xe3\xa8\x82\x47\x87\xec\x71\xc0\x22\xa0\xf6\xfa\x12\x09\x75\x68\xbd\xcc\x6b\x0e\x25\x65\x67\x0e\xe2\x7d\xa8\x1b\xec\x10\xc3\x2e\x5c\x48\xbf\x53\x00\xc6\x69\x2c\xa0\xa3\xfe\x0c\x3b\x7b\x00\x56\x88\x8f\x91\x91\x32\x0a\x44\xb1\xbd\x67\xc6\x9c\x22\x90\xce\xb2\xb2\x05\x38\x41\x75\x74\x55\x46\xc0\x87\x17\x88\x2c\x02\x87\x34\x3c\x60\x12\x95\xdb\xf6\x56\xc7\x0d\xb8\xf1\x00\x11\x16\x55\x7e\x8d\x38\xed\xd0\x94\x6d\x31\x6f\x66\xbe\xf2\x27\x10\x6d\xcf\xf3\x75\x94\xd9\x65\x83\x5e\x3f\xbf\xf0\xbe\x3f\xb4\xba\xa4\x32\x0e\xcd\x05\xfd\x4d\x45\x45\xab\x49\x4f\x6d\xbb\xb9\x9a\xc8\xc4\x12\x1d\x37\xc1\x0a\x75\x86\xf9\xa4\x53\xc7\x0b\x33\xb6\x6c\xab\x66\x07\x2f\xb1\x16\x44\x57\x85\xd2\xfd\x76\x45\xd9\xf6\x50\x01\x86\xa9\x68\x6b\xa7\x39\x7a\xc6\xc4\xa7\xf8\x97\xad\x86\xff\xff\x7d\xfd\xfa\x4e\xa3\x9f\xaa\x7f\xb1\x4c\xe1\x7f\xfc\xe9\xc6\x62\xde\xaa\xdb\x31\xf4\xff\xf3\xdf\x10\x76\xde\xaa\xaf\x63\xe8\xc7\xf9\xdf\xff\x51\x2f\xcb\xf3\xff\x0f\x00\xfb\xbe\xdf\x77\xe4\x3e\xbd\x2b\x00\x06\x41\xf0\x53\xf9\x1f\x5f\x5b\x53\xee\xcc\x74\xfc\xfb\x3f\xc0\x2f\xf0\x0b\xc3\x90\x2f\x18\xc1\xee\xc8\x3f\xfe\x0d\xe1\xff\x0d\x61\x8b\xf2\x31\x7f\x97\x80\x3f\x8a\xcf\x74\xa9\xbf\x1e\x4d\xdf\xff\xfb\x3f\xfe\x0d\x46\x1e\x3f\xff\xfd\xe3\xab\xf8\xf7\x7f\xe8\x30\x42\x7d\xe1\x48\x0d\x11\x77\x72\x83\x40\x4c\x82\x11\x2a\xc0\x91\x6b\x40\xb0\x3b\xfe\x05\xd6\x08\x7e\x47\x72\xe2\x4e\x7d\x81\x5f\x10\x7a\xc7\xee\xd4\x17\x44\xdd\xf1\x2f\xf8\x8e\xcf\xd4\x1d\xfe\x42\xef\xd0\x17\x04\xdf\xa1\x2f\xe2\x0e\xa5\x30\x7a\x47\xb1\xaf\x6f\xfc\x58\x06\x7d\xe1\x77\xf8\x0b\x02\x3f\xf5\xc0\x3b\x81\xfd\xc2\x6f\x11\x74\x27\xbf\xcf\x44\xb1\x3b\x4e\xfd\xc2\x9f\xa2\x1f\xbf\x44\xd4\x17\x8c\xdf\x31\xf2\x17\x7e\x8b\x7e\x29\x24\xbf\x10\xf0\x8e\x51\xbf\xf0\xd7\x59\xdf\x66\x20\xf9\x0f\xec\xfe\x53\xfd\x0f\x08\xba\x63\x5f\xf0\x9d\xf8\x01\x51\x77\xe4\x53\xa8\x3f\x25\x28\x80\x70\xb2\xfe\x01\x11\x77\xec\xbb\xa1\x1f\x9d\x18\x94\x22\xe4\x1d\x21\xbe\xbe\x11\xfc\xd6\x09\xdd\x3f\xc6\x20\x5f\x10\xfe\x1b\x7c\x0b\xf0\x3b\xf9\x03\xb9\x13\x5f\x10\x72\x47\xd0\x5f\xf8\x2d\x41\xee\xd8\x0f\xec\x4e\x7e\xc1\xd4\xa7\xa5\xdf\xf8\x4b\xd9\x0f\xe2\xe3\x37\xec\x8e\x93\xbf\xf0\xe7\xf1\x1f\x9f\xe3\xc4\x17\x04\x7f\x5e\xdf\x47\x90\x3b\xfe\x03\xbb\x63\x5f\x10\x71\x87\x7e\xc3\x6f\x09\x7e\xa7\x7e\x20\x77\xf4\x0b\x85\x3e\x1e\xf9\xc6\x5f\x5a\xc0\x3b\xf5\x03\xba\xc3\xf5\x0f\x88\xbc\x63\x01\x04\xa1\xf5\xa7\x70\x0d\x10\x44\xdd\xa9\x1f\x18\xb4\x41\xd8\x1d\xa9\x7f\xa0\xd4\x1d\x0e\x20\x90\xac\x51\xfc\x8e\x7c\x8e\xa1\xf5\x8f\x4f\xf1\x77\x9f\x90\x01\x8e\xd4\x38\x71\x0d\xf0\xc7\x2d\x04\x7c\xa7\xf2\x3b\xf9\x85\xdf\xa9\x2f\xe4\xe3\x03\xe8\x4e\x7d\x11\x77\xf4\x0b\xc2\x66\x08\xfc\x58\xf2\xb1\x9d\xbc\xe3\x9f\x42\x8a\xc0\x77\x1c\xfa\xfa\xc6\x5f\x8d\x06\x7f\x79\x10\x06\xef\x18\xfc\x0b\x7f\xf3\x21\xfe\x03\xf9\xb4\xf2\x8f\x96\xff\xf2\x1e\xfc\xa1\x18\x48\xfe\x42\xf0\xf7\x9e\x47\x3f\x5d\x00\xfd\x86\xdf\xed\xbe\x13\x3f\xd0\x0f\x27\xe1\x3b\x49\xfc\xc2\x6f\x01\x7c\xc7\x7f\xa0\x1f\xf5\xf8\x87\x21\xdf\xf8\x2d\xc1\xee\xd0\xc7\xc5\x5f\x08\xf6\x79\x7d\x1f\x23\xef\xf0\x0f\xf8\x8e\xf6\x3f\x20\xe4\x8e\xfe\x80\xef\x58\x4a\x52\x77\x02\xff\xfa\xc6\x5f\xfc\x42\x7f\x9e\x48\x7c\x21\xc8\x1d\x83\x7e\xe1\x2f\x11\x78\x47\xbf\xbb\x1d\xbe\xc3\xbf\xe1\x6f\x66\x23\x3f\xc8\x0f\x5f\x3f\x91\xf2\x13\xbe\x8f\xc3\xf7\x9f\x8c\x25\xbe\x60\xfc\xf3\xfa\x15\x13\xd0\x1d\xf9\x01\xc3\x77\xf4\xeb\x13\x76\xd8\x2f\xfc\x25\x83\x7f\xd2\x02\xff\xc2\xb1\x3b\x49\xfd\xc2\x5f\x22\xec\x43\xf6\x3b\x99\x13\xf7\x8f\x27\x3f\x7c\xfc\x44\x10\x79\x87\xbf\x3e\x4d\x41\xd0\x3b\x8a\x7f\x7d\xe3\xef\xd7\xa1\xbe\xf0\x4f\x70\x90\x77\x18\xfa\x85\xbf\x45\x2c\xf5\xf5\x89\x16\xf4\x67\x68\xc2\xbf\xd9\xfb\x85\x7c\xba\x05\xea\x7f\x40\xf8\xa7\x99\x77\x3c\xff\x01\xfd\x6c\xf3\x87\x90\xc4\xc7\x01\xf0\x0f\xe2\xd3\x24\xe4\x0e\xcd\x3f\xc8\x9f\xdd\x82\x7c\x2a\x43\x9f\x42\x8a\x22\x77\xea\xeb\x27\xfc\x4e\x57\xec\x0b\xfa\x84\x29\x75\x47\x89\x5f\xf8\x1b\xc7\xc9\x2f\xe4\xfe\xd3\x46\x1c\xf9\x85\xbf\xc5\x05\xf1\x85\xde\xf1\x4f\x1e\xfa\xb0\x03\xfd\x9d\x1d\x3f\x3e\x9a\xb0\x3b\x9a\x83\xdf\xf2\x3b\xfc\xf5\xd1\x41\x7c\xe8\x87\xcc\x9f\x16\xfd\x0c\x52\xf8\x0b\xbb\x23\xfd\x27\x8b\x7d\xc1\x77\x32\xff\x44\xf7\x17\xfc\x6d\xc3\x47\x84\xff\xcc\x5c\x9f\x73\xb0\x99\xf8\x2d\x39\x7d\x0a\x30\x74\x47\x53\x04\xfa\x99\x1d\xa0\xdf\xb2\xc3\xa7\x07\xd1\x4f\x1d\xe4\x13\xcd\x30\xf1\x0b\x7f\x8b\x74\xf4\x8b\xfa\xb4\xe3\x67\xe6\x42\xfe\x94\xbf\xa0\xcf\x59\xf8\x1d\xff\xc2\x7e\xbe\x7e\x1d\x24\x7e\xa6\x27\x34\xff\x49\xbf\x0f\x79\x3f\x1c\x24\x7f\x20\xd0\x1d\xff\x41\xde\xb1\xf9\x93\xc9\xa8\x0f\x01\xd1\x1f\x3f\x69\xf0\x89\xcd\x1a\x22\xaf\x7f\x00\xff\x2c\xbb\xa3\x38\x55\xa6\xf0\x77\x76\x47\xc0\x9f\x99\x0b\xed\x49\xf4\x0b\x25\xef\xd8\x17\x89\xfe\xf8\xfc\x1f\xe0\x44\xff\xe3\x57\xf9\xc7\x2f\xd9\x46\x11\xff\x42\x23\x9e\xe6\x69\x01\x7d\x6b\x84\x40\xec\x13\x03\xe0\x1d\xea\x7f\x7c\xa2\x1d\xbb\xc3\x29\x44\xde\x21\xea\xeb\x1b\xbf\xe9\xf2\x89\x65\xa4\xc7\xc1\x4f\xde\xf8\x59\x03\xbd\x63\xd8\xd7\x37\xfe\xe2\xe0\xa7\xd1\xe0\xcf\x2a\x3f\xfe\x95\x92\x1f\xc8\x1d\xd1\x20\x18\xf9\x79\xb9\xff\xac\xe3\xdb\x71\xe0\x35\x7c\x37\x00\xfe\xcd\x20\xfc\x53\x95\x40\xbe\xbe\xf1\xbb\xea\x27\x47\x41\x58\xff\xe9\x52\x30\x85\xb0\x3b\x46\x7c\x7d\xe3\xf7\xa5\xe0\x4f\x87\xdf\xf1\x3f\x9b\xf3\x1f\x55\x7c\x91\x77\xfc\x07\x84\x05\x04\x75\xa7\x52\x18\xfc\x82\xc1\xdf\x89\xf0\x89\x3e\xfc\x1a\x7e\x40\x18\x78\x27\xef\xe8\x7f\xd6\xff\xe3\x97\xfe\x8d\x00\x3f\x62\xf4\x8e\xfc\x24\x30\x42\xfe\xa1\xfa\x63\xdd\x9f\xfc\xf5\xcf\x2c\xfc\x5c\x65\xfb\xf1\xcf\x55\xfc\xf8\xb6\x4e\x43\xc8\x4f\x86\x26\xef\xff\xaa\x2b\xff\x4c\x0e\xe8\x73\xfe\x17\x4c\xf5\xc4\x67\xc4\x44\x91\x3b\xba\x91\xf8\x9d\xe8\x7f\xfc\xfe\xfe\x67\xe9\xc7\xa7\x14\x10\xf0\xa7\x2f\x7e\x9d\x31\xfc\x0c\x61\xa4\xff\x13\x75\xfe\x23\xc3\xb6\x1f\xd4\x1f\x14\xfb\x6f\x1a\x43\x7d\x41\xc8\x67\x08\xbb\xc3\x34\x84\xdd\xf1\x8f\x4f\x3e\xf8\xed\x00\x8a\xfc\x82\x3e\x63\xf0\xf6\x91\xa7\xff\x59\x0e\x61\x9f\x44\x84\xdd\x89\xfa\x5f\xcb\x7f\xc2\xf6\x4f\xe5\x3f\x7e\x97\x5f\x03\xf8\x85\xa3\x77\xac\xfe\xfd\x42\xd8\xd7\x37\xfe\xca\x36\x9f\xd4\x42\xf6\x3f\x5d\xf1\xc9\xb1\x9f\xc2\x67\x04\xf9\x17\x55\x7f\x90\xd7\x40\x7e\x46\xb6\x8f\x23\xea\x1f\x1f\x76\xfe\x87\x6b\x83\x3f\xfe\x93\x6d\x10\xf2\xf5\x8d\xdf\x24\x83\xbf\x88\x3b\xde\xff\xba\x10\x12\x40\x28\xf9\x61\xdb\xcf\xb7\xd4\xa7\xfa\x67\x40\xbe\xff\x36\x26\xfe\xac\xfc\x4f\x1b\x09\xfe\xe1\x84\xfa\x8e\x07\x38\x71\x87\x35\x88\xfc\x0c\x4a\x18\x75\x0d\x3f\x70\xea\x4e\xfe\x40\xc1\x4f\x3f\x83\xe0\xe7\xb6\xeb\xa7\x6e\xe2\xa7\x29\xc4\x6f\xa6\x7c\xb7\xfe\x0e\xd5\xff\xd4\x39\x5f\xdf\x2d\xee\x7f\xfc\x66\xeb\xa5\xa3\x9f\x9c\x8c\x91\x77\xea\xfb\xe0\x17\xf9\xb9\xf1\xc0\xef\x48\xfd\xcf\x3c\xf1\x47\x2f\xfe\xea\x66\xfc\xe7\x28\x80\xff\x31\x0a\x7c\xc6\x19\xe2\xfa\x24\x36\xea\x0b\x42\xc9\x8f\x43\x3f\xea\xe0\xdf\xfa\x03\xf9\x8f\xfe\xf8\xfa\x9c\x81\x6f\xff\x94\x55\xe0\xd7\x6f\x7a\xfe\x05\x43\x41\x12\xc9\x30\xf4\x1f\x3f\x0f\xfc\x98\x9e\x69\xde\x2c\xe7\xbf\xff\x03\xbc\x43\xd8\xff\x12\x42\x9f\xd1\xe5\x43\xf8\x4f\x52\xfc\x8d\xff\x9f\x77\xff\x37\xb5\x82\xbf\x69\xa5\xc8\x9f\x77\x3b\xc8\x9d\xfc\x2d\x8c\xbe\xfe\xb3\xce\xcf\x5c\xe0\x53\x02\xe9\xff\xf1\xbf\xf3\xe9\xe7\xd0\x14\x7f\x9e\xa3\xfc\xbf\xbb\x5f\x72\xfd\xe7\xfd\x92\xbf\x7f\x5f\xa5\x30\x13\x35\xf4\xa7\x45\xf5\x55\x41\xe3\xc3\xce\x86\x78\xda\x15\xc5\x43\x64\x1a\x74\x96\x83\xf7\x02\x13\x72\x73\x18\x00\x3b\xde\xd8\xe3\x11\x8c\xf6\x1c\x29\xcd\x45\xca\xf4\xf4\x72\x18\x91\x4f\x75\xdf\x0f\xaf\xe9\x31\x46\xdd\x45\x90\x10\x8a\xe0\x36\xd7\xb5\xaa\x77\x46\x6b\x52\x52\x38\x46\x61\x07\xf2\x3e\x14\x81\x2f\xbd\x2b\x55\x43\xbc\x18\x8a\xe7\x43\x9e\x8e\x76\x75\x1c\x81\x67\xc5\x91\x00\x50\x7f\xd9\xd2\x77\x0b\xcc\x67\x58\x3d\x7a\x1f\x9b\x49\x0a\x7a\x6d\xe2\xa4\x94\x96\x92\xce\x0f\xa6\x2a\xdd\xe7\x18\xde\x4e\x5e\x56\x02\x17\xe5\x78\xe6\x40\x84\x4b\xf4\xe0\xd7\x63\xab\xc1\x45\x39\x4c\x1e\x1d\x58\x1f\x3c\x4f\x32\x42\x18\xad\x30\x39\xc7\xf6\x94\x04\x9b\xf4\x2b\x4e\x39\xd0\x5f\xb9\xd2\xba\xba\x6c\x1c\x0f\x68\x68\x03\x0a\xe8\xf5\xe7\xad\xb9\x18\x95\x97\x77\x5b\x37\xaf\x6d\x54\xc4\x29\xae\x6b\x86\xab\x04\x75\xd1\xdb\x81\xe9\xa9\x28\xc1\xd0\x30\x7d\xba\xad\x36\x76\xa3\x3e\xf2\x9d\x1d\x57\x8f\x9e\x0d\x6a\x35\xd2\x96\x1b\x50\x38\xfa\x09\x17\x98\x29\x15\xc1\x68\x4d\x47\x29\xf9\x8b\x16\x90\x2b\xbc\x63\x80\x4b\x90\xfe\xc5\x28\xbb\xa6\xb3\x64\x45\xcf\xd3\x2c\xbf\x4e\x0a\xa8\x52\x84\x08\x8d\x61\xab\xd4\x40\x1d\xf8\x2e\x23\x14\x77\x97\x91\xa7\x5c\x38\x2f\xa8\x63\x22\x26\x51\x68\x5f\xed\x32\x7c\x2f\x50\xea\x21\x5f\x99\xb2\xd4\xc5\x88\xe7\x72\xcd\x83\x91\x1f\x66\xa7\x85\xe6\xc3\x5c\x0f\x45\x42\xf3\x60\xe9\x33\x1c\x5e\xb1\x06\xc8\x2d\xc9\xae\x13\xd1\x7e\x73\xfc\x3e\xe0\x15\x76\x6d\x08\x76\x38\xad\xd4\xa5\xd0\x8b\x05\xf1\x44\x2f\x0b\x87\xe7\x1d\x83\xc6\x8b\x96\x09\xa5\xd9\xa5\x6e\xd4\xc3\x71\x91\x27\x45\xbf\x53\x33\xca\x6a\x5e\xd3\x7b\xdf\x6e\x57\x58\x84\x4d\x42\xa1\x6d\xde\xe8\xc0\xa8\x7e\x4a\x22\xa2\xcb\x41\xcf\x27\x57\xca\x65\x85\xa9\x9a\x64\x1b\x9e\x80\xf7\x4e\xc5\x59\x1f\x34\x54\x23\x55\xaf\x1a\xe5\x47\xfe\x38\x51\x85\x09\x4b\xdb\x78\x82\x2d\x04\xea\xf6\xc2\xa0\xbc\x62\x56\xf8\x4b\xd0\x65\x20\xe3\x25\xe4\x29\x1a\x8b\x80\x6a\x26\xdd\x4a\xfa\x61\x42\x85\xb8\x85\x68\x1b\x5d\x5c\x43\xc8\x3b\x0e\x7a\x0c\xd8\x2a\xce\x69\x1a\xf5\x86\xea\xc5\x3a\x66\xdc\x58\xea\x34\xce\xe8\x16\x47\xe3\x8d\x2e\x5c\xfc\x91\xdb\x12\x45\x1f\x9d\xdf\xec\xd9\x79\xb3\xaf\x72\x5b\x46\x01\x36\x7d\xb2\x67\x3c\xa8\x21\x1f\x66\x0a\xfb\x26\x04\x08\x7b\x21\x7a\x12\x0f\xbb\x9e\xa4\x03\x10\x7a\xdb\x7a\xcb\xbc\x40\xe7\x68\x32\xd5\x7a\x8c\x14\x2d\x45\x89\xc4\x5c\xf1\x41\xe2\x78\x52\x78\x6a\xb7\x06\x63\x51\x4b\xeb\xab\x1c\x5d\xa8\x06\x36\xf4\xf1\xd8\x8e\xd7\xb9\x65\xfe\x4a\x2f\x56\x73\x25\x20\xf7\x24\x22\xe8\xe1\xcd\x37\x81\xa6\x72\x7d\x0c\x0b\x34\x11\x29\xd0\x30\xdb\x69\x08\x84\xab\xf4\x72\x6b\xe7\x45\x9a\xe5\xc4\x32\x2e\x8a\x24\x22\xf1\xbf\x74\x19\xd6\xf0\x44\xfe\x5e\x5f\x96\x8c\xc7\x1f\x5b\x80\x90\xbf\x7e\x16\xf1\x9d\x12\x51\x78\x3c\xdd\x59\x88\xe5\x2c\xb0\x1f\x94\xc3\x0b\x8c\xd4\xc5\x8c\x23\x5b\x4a\x8d\xee\x6f\x03\xe1\xe6\x04\xd5\x2d\xd1\x22\x33\x60\xf7\x59\x59\xe2\x77\x8c\x8f\xc1\x1d\x44\x27\x4a\xd6\x72\x87\x17\x87\x3d\xa8\xd2\x28\xcb\xa2\x62\x2c\xe0\x2c\x32\x0e\x2b\xad\xc5\x33\xbf\xca\x6c\xb9\xde\x17\xb2\x95\x14\x45\xa0\x60\xe8\x38\x52\x17\x8e\x58\x5e\x66\x2b\x9a\x4b\xb8\xab\xc7\x44\x09\xb6\x0e\x2d\xbd\xa9\x1c\x09\x8f\x39\xd8\xf2\x72\x18\xb2\x73\xa6\x4e\x0f\xbf\xad\x92\x42\x4e\xa9\x55\x3e\xce\x67\x61\x71\x1c\x16\x0f\x35\xb6\xc3\xf8\xae\x77\x7c\x3d\x91\xca\xc2\x2d\x2b\x6f\x26\x02\xfb\xde\x0c\x00\x5d\x95\xc4\x10\x25\xd0\xc3\x28\x0e\x23\x23\x80\x85\x89\x54\x30\x68\x0d\x89\x96\x7a\x98\xf7\x1d\x13\xd9\xd3\x40\x6f\xeb\xb5\xde\x4c\x6d\xb1\x67\xdf\x3a\x2c\xfb\xc0\x13\x9d\x9e\xec\x96\xa1\x77\xc2\xbc\x65\x7c\xc0\xea\xba\x5d\xbd\xce\x6a\xbe\x69\xc2\x0c\xd5\xb7\x42\x2c\xc8\x6c\x4c\x41\x7b\x88\x4c\xca\xd4\x70\x25\xae\x76\x7a\x33\x85\x44\x55\xa7\x13\x09\x50\x94\xad\x8c\xc7\x46\xc4\x07\x39\x69\xd2\xad\xf7\xf9\x6a\xbb\x04\x32\x2e\xea\xeb\x36\xa2\xd0\x3c\xd2\xa2\x23\x62\x95\xcf\xef\x6c\x7f\xd5\x52\xb1\x2d\x8b\x70\x3c\x8c\x33\x56\x41\x7e\x54\xa6\x4b\x55\xb1\x52\xcc\x1f\xd0\x4b\x9a\x20\xd1\x3c\x96\x76\x97\x6f\xcf\xc7\x36\xa0\x15\x10\x42\xaf\x45\xa9\xca\x77\xcc\xc3\x6e\xa4\xb8\xb2\x46\xdd\x42\xb0\xed\xc0\x81\x75\x6b\xfa\xe0\xa2\xca\x56\xab\xcc\x88\x8e\xe4\x85\x60\x9b\xad\xb2\x8d\x6a\x77\xae\x1f\x15\x39\x74\xab\xf2\xbc\x86\x04\x49\xb4\x06\x75\x95\x2b\x86\x2d\x72\x1c\x7f\x29\xb6\xa4\x8b\xd4\x0d\x32\xe4\xa7\x7f\xf6\xc7\x21\x2d\x6b\x88\x57\x7c\xe3\xc9\xeb\xcd\x40\xcf\xb6\x08\xab\xe5\x04\x4f\x6f\x28\x8c\x56\xb8\xf2\x5d\x6d\x63\x50\xf7\x09\x5d\x5b\x6e\x72\x3b\xb9\x69\x01\xe1\xc2\x24\x1f\x48\x06\xd0\x20\x97\x10\x42\x1c\x8d\x73\xf1\xa4\x5b\x5f\xe7\xcc\x56\xc6\x2e\xab\x7a\x4c\xcc\xec\x4c\x45\x5d\x8b\x75\x22\x3d\x18\xc6\x07\x46\x91\x16\x9d\xe5\x08\x65\xb3\xc2\x7a\x0f\x36\x96\xb7\x8c\x15\x1a\xe8\x32\x98\xaa\x5c\xda\x54\xf4\xd3\x2b\x4a\x4d\x3e\x5d\x2c\xf1\x5a\xd4\x17\x56\x89\x88\x8b\x71\x46\xbb\xd2\x2a\x66\xb4\xaa\xf2\xb0\x62\x55\x06\xa7\x8e\xe9\xdc\xa2\x1c\xd8\xc6\xad\x5c\xe0\xdd\xd9\x86\xe6\x96\xd6\x72\x30\x2d\xaa\xb9\xec\xfe\x10\x16\x1e\xec\xde\xaf\x57\x44\x24\x81\x3e\xae\x54\xd4\xeb\xd1\x09\xf7\x84\xce\x83\xc5\x45\x23\x0d\x6d\xd8\x67\x8c\x6f\xe1\xc1\xe2\x90\x1f\xa3\xd0\xe5\x9d\x46\x1e\xd7\x38\x60\xb3\x46\x64\x6f\x57\x83\x15\x0e\x42\x8d\x52\xf0\x82\x18\xff\x5c\x75\x91\xa6\x9d\x59\xc0\x97\x2c\x2b\xd1\x46\xe5\xa0\x37\x61\x0e\x58\x23\x30\xc5\x10\x42\xee\xcc\x3d\x7a\xad\x59\x19\x7c\x8e\x28\xf0\x46\xd3\x36\x27\xd1\x21\x51\x84\x60\x3c\x5e\x7f\xf5\x4f\x34\x0c\x4f\xf4\x6f\x96\x3c\x98\xdf\xef\x38\x3a\x8a\x7a\x83\x10\xed\x1f\x04\xf5\x9c\xdf\xde\x7b\x6d\x83\x25\xcb\xcb\x34\x1b\x93\x19\xe5\x62\x47\x72\x27\xbd\xc6\xb9\xea\x45\x10\xef\xf1\x46\x3f\x26\x1a\xb8\xc9\x0f\x94\x99\xba\x1b\x0b\xb2\x8f\x23\x70\x38\xa6\xbe\xc9\xb0\xf1\x4a\xae\xf7\xd3\x85\xb8\x60\xcb\x16\x1f\x71\x15\x2b\x1f\x48\xd7\xed\x67\xa5\x2f\xf3\x79\xa4\x0a\x8f\x40\x46\x93\xc4\x02\x80\xa1\x24\x50\x22\x48\x53\x2b\x16\x40\xe3\x7a\x1b\x5a\xf5\xf8\xcc\x64\xba\x92\xa9\x91\xa2\xcc\xf0\x98\x4a\x12\x19\xbb\xe6\xa2\x6a\x8e\x4b\x4b\x04\x01\x95\xed\xd0\x50\xd2\xc4\xa0\xe8\x18\x80\x72\x34\x16\xd5\xca\x82\x9d\xae\x41\x3e\xc7\xbb\xf8\x19\xa5\x0b\x65\x8d\x3d\x2c\x32\x2c\x08\x4b\xef\x56\xc7\x62\xa2\x46\x2d\xf2\x46\x08\x8b\x2c\x04\x0a\x4a\x99\xef\xc3\x1f\x7b\x62\xcd\xe5\xe2\x51\x6f\x37\x46\xe6\xb6\xdb\x83\xc9\x5b\xe2\x09\x2c\x91\x6e\xbd\x67\xd8\x89\x02\x6f\x47\xcd\x08\xf6\x47\xc1\x7b\x47\x6c\x96\xc5\xc4\xf2\xd4\x67\x1a\x42\x04\xce\xe5\x68\xd3\x46\x2b\x85\x17\x7d\x45\x9b\x41\xcb\xaa\x29\xb6\xe3\xdd\xd9\x7a\x0f\xc7\xc1\x5f\x70\xff\x4e\x91\xf7\xf8\xa4\x17\x44\xc4\xd3\xa2\x2a\xec\x9a\x79\x0e\xa5\xd6\x09\x53\x61\x0c\x73\xfb\x34\xad\x29\x62\xde\xb6\xc7\xe5\x83\x20\x18\x2e\xd1\x20\xba\xc3\x5d\x97\xc5\xee\xc0\xb6\xa5\x64\xd3\xf9\x37\xd6\xb4\x8f\x01\x42\x19\xa6\xde\x94\x5c\xd2\xc4\xa7\x68\x79\x26\xad\x1c\x47\xa9\x65\x6f\xa7\xa2\xbb\x78\x6d\x99\x42\x42\x45\x6c\x0a\x95\x30\xf2\x43\x88\x8a\x35\x34\x7a\xad\x23\xad\x0b\xf5\xf8\x82\x98\x57\x18\x57\x69\x0c\xe9\xb4\x44\xbb\xb6\xd9\xf8\x14\x7e\xa9\x57\xe7\x13\xf8\xb0\x97\x75\x6a\x6e\x07\x5e\x53\xab\xbe\x11\xaa\x60\x20\xce\xf4\xd4\xd0\xc9\xa3\x65\x54\x72\x6a\x74\x77\x7b\x84\xa2\x8e\x3e\xbd\x81\x60\x9c\x39\xc8\xf9\x96\x2f\x9d\x72\x2f\xf7\x55\x29\xca\x38\xa9\x79\xd7\x8b\x6f\x09\x24\xd9\x5c\x69\x47\x66\xd1\x34\x76\x76\x79\x51\x7c\xba\xa1\xb2\x49\x0b\xa7\x1a\x93\xd0\x3c\x9f\xb3\x02\xae\xbd\x3c\x73\x9c\xcf\xb2\xb4\xa7\xf7\x8c\xdd\x19\x6b\x5a\xf3\x67\x93\x78\xb9\x36\x0f\x02\xa3\xa6\xf6\x91\x9a\x1d\x86\x78\xbd\x54\xaa\x9d\x4e\x80\x74\x4b\x4f\x13\x5b\xd5\x8c\xd9\x51\xb3\xba\xc8\xdb\x6b\xb1\x5e\x2e\x2a\x30\xa9\x33\x2a\xae\x13\x91\x4b\x0b\x73\x66\x8d\xf4\x02\x83\xd9\x3b\x9c\x18\x82\x8a\x69\xce\x84\xef\xe8\xac\x2e\x70\x55\xd1\xd7\xb9\x37\x05\xad\x1b\x00\xb5\xca\x96\x9b\x54\x3d\xa3\x71\x26\x26\x08\xc8\xe0\x70\xc8\x2e\xf1\xd4\x2b\x70\xb6\x49\x7a\xfb\xcf\xc7\x78\xf3\x79\x5b\x05\x01\xc2\xad\x97\x3d\x9b\x24\x05\x6f\x0b\x89\x74\x92\xc3\x65\x31\xa2\x76\x03\xde\xcb\x88\x12\x03\xe0\x15\x14\x8e\x97\x25\x29\xd3\x7e\x23\x9b\x04\xed\xe3\x18\xb6\xc5\x15\x69\x8a\x5a\x3e\x4c\x22\x26\x9e\x24\x4d\xef\xb4\xc6\x8a\x89\xca\x5b\x8c\xc8\xfe\xf5\xc9\xe2\x6f\xf6\x44\xc8\x1f\x77\x1a\xf3\xef\x9b\x8d\xad\x99\x53\xf4\xaf\x61\xf4\x99\x6c\x4a\x41\xbf\xf4\x6d\xae\xf1\x45\x96\x85\x6e\xca\xf0\xae\x8f\x29\x5a\x80\x8a\xd9\x22\xa5\x21\x50\xf9\x81\xd2\x01\x18\x23\xb3\xa1\x0a\x60\xec\xa7\x32\xfb\x9a\xe4\x47\x5b\x05\x6e\xcd\x37\xa2\x80\x2e\x9c\x59\x98\xc0\xc3\x2c\xcd\xd4\x55\x97\xa6\xc4\xc4\x64\x25\x9e\xd7\x85\x94\x40\x4e\x5c\x8b\x2a\xca\xa9\x8c\x6e\x23\xf5\xbc\x01\x16\x52\xa3\x25\x9a\xe2\xd6\x86\xf3\x93\xcd\x70\xcd\x49\x58\xd8\x3b\x87\x2c\x28\x5a\xf0\xc8\x22\x75\xac\x6c\xa3\x09\xf7\x95\x5b\x11\x66\x6b\x39\x94\x9e\x58\x3c\x37\xa3\x68\x8c\x92\x8a\x37\x5b\x2b\x51\xa6\x41\xad\xc1\x7b\x3a\xc3\xf9\x22\x07\x02\x7a\x3f\x09\x94\x39\x54\x01\x5e\x76\x59\xda\xe8\xe9\xf6\x00\x7a\xc8\x83\xe3\x27\x78\xe5\xa5\xd4\x5c\x0f\x33\x49\x81\xc3\x19\x1f\x8c\x53\x8b\x28\x6b\xbf\xe8\xb8\x99\x98\xb0\x8c\xb8\x93\x26\xb9\x06\x2f\x1b\x28\x2f\x23\x16\x8a\x98\xfd\xed\x45\x92\x25\xc1\x5b\x88\xe7\x39\xc3\x30\xba\x8c\x33\xb3\xeb\xf3\xf6\x95\x76\xa2\x86\x1f\x0c\xb8\x6c\xed\xc9\x1c\x8e\x71\x14\xec\x92\xc3\xd1\x83\x74\x28\xef\x4c\x43\x8f\x33\x2b\xd8\x6b\x1f\x41\xb1\xe3\xf5\x4b\x9e\x78\x8a\x81\xc5\xa3\xe3\xb9\xb0\xd7\x24\x62\x46\xcb\x65\x29\xe1\xce\x7d\x82\x13\xe7\x94\xd7\xdb\xde\x59\x59\xa6\x91\x49\x94\xde\x20\x30\xa8\xfa\xc0\x63\xc8\x6b\x82\x91\x10\xbd\xed\x98\x7b\xb3\xb1\xa9\x9e\x32\x2a\x42\x96\x4a\xaa\x4c\xd2\xd7\x6c\x9a\x65\x89\x4a\x3f\xa8\x41\xb5\x2d\x04\xe4\x43\x7c\xe0\xa5\x67\xdc\x90\x47\xae\xf0\xc5\xa5\xaf\x79\xfb\xe8\xd4\xfc\xed\x3d\x86\xd7\xd0\x08\x31\x73\xb0\x02\x20\x17\xb7\x2a\x3d\x55\x65\x9f\xec\x56\x2a\xde\x34\xb6\xa1\x92\x4a\xb0\x2f\x14\x55\xdb\xc4\x08\x9f\x69\x95\xbe\x9e\x84\x4d\xb3\xdd\x0c\x4a\xd4\x35\x86\x08\x8e\x35\x29\x8c\x72\xd7\xc4\x73\xd3\x65\x2a\x99\x44\x96\xc1\x22\xba\x75\x24\x79\xbb\xf1\x4e\xf3\x71\x16\x89\x17\xae\x5d\x33\xbf\xa6\x74\x6f\x58\x03\x55\x13\x9c\xeb\x06\xad\x76\xb2\x7a\xf7\x7c\x72\xf2\x4d\x74\x61\x77\xb1\x43\x1a\x72\x7a\x75\x02\x23\x0c\x1f\xe1\xe8\x86\xdb\x52\x37\x74\x5c\xda\x1d\x02\x15\xea\xc1\x2b\x3c\xd5\xdb\x0c\x30\xef\xa5\x8e\x1f\x5b\x78\x41\x7e\x75\xbb\x7c\x2e\x6f\x75\x4b\x1f\xc0\x1a\x79\x1e\x7c\x2b\x0c\x29\xc2\x66\xf2\xca\xae\x05\x31\xe9\x39\xa8\x69\x50\x52\x0d\x7c\xff\x14\x95\x25\x44\x98\x1b\x84\x49\xb2\x68\xc8\xde\x5b\x8f\xe5\xde\x94\x88\x06\xf4\x51\xc8\x78\xcb\xa3\xc3\x9f\x7d\x9c\xad\xa8\x83\xbd\xec\xcc\x66\x52\xba\xa6\xb0\x47\xa0\x26\xec\xf8\xb4\xd9\x31\xa3\xb8\x77\x98\x9c\x6f\x87\x77\x5c\xdc\xe0\x4a\x7f\xbf\x9d\x52\x1a\xd5\xc4\x7b\x41\x59\x94\x21\xcf\x1b\xb5\x75\xfb\x48\x74\xbb\x6a\x38\x4f\x6e\x4a\xa9\xb4\x11\x54\x26\x1e\x85\x9b\x93\x3b\xfc\xcb\x86\x4b\x68\x40\x9c\x9f\x1b\xa8\x9f\x54\x77\x51\xe7\xcc\xf2\xf8\x5f\xbd\xba\x73\x2a\xfe\x66\x3b\x15\x36\xd8\x1f\xd3\x94\xee\xfb\x09\x71\x60\xc8\x56\x44\x78\xf0\x90\xea\x38\xfe\x33\x8c\xeb\x92\xd6\x0c\xc6\x77\xfc\xe0\x24\xf2\x93\xf2\x3b\x13\x57\x43\xe0\xa6\x65\x0b\x28\x5b\xb3\xb0\x36\x68\xa5\x31\x99\xff\x12\x52\x7f\x8d\x78\xcf\x57\xd9\x38\x05\x5b\x17\x3b\x13\x38\x31\x31\x8c\xc8\x30\x7d\xf0\xa2\x67\x35\x70\xd6\xf8\x30\x73\xa2\xbd\x46\x5d\x94\x8d\xd8\x6a\xc0\xa2\xc4\xfc\x6d\x78\x9a\xce\xf1\x6c\x79\xa0\xcb\x8c\x57\x08\x82\x18\x17\xac\xa4\x17\xee\x90\x44\x60\x64\xf2\xe8\x84\xca\xa8\x94\x61\x39\x0f\xd7\x72\x5a\x45\x6e\x41\xdb\x0b\x01\x87\x6b\x62\x31\x12\x33\x82\xeb\x11\x18\x28\xa3\x77\x30\x17\x60\xe5\xb2\x07\x35\x34\x2f\x16\x9c\x26\xb6\x78\xe2\x54\x85\xd9\x40\x8d\x9b\x9a\x01\x2e\x27\x76\x8e\x72\xb7\x5f\xfa\xee\xef\x35\x2c\xec\x7a\x91\x67\x5c\xc3\x26\x76\xd4\x77\x2f\x81\x7d\xf2\x93\xe5\x01\x7b\x53\x43\x71\xab\xc9\x23\x6d\xe4\xdc\x0d\xf0\x53\x2a\x5b\x91\x5d\xe9\xc5\xed\xcd\x24\xec\x50\x2e\xf0\xcd\xc5\x75\x1e\xab\xd0\x49\xec\x13\x8a\x06\x64\x02\x8c\x58\xae\xae\xb9\xf2\xb0\x0c\x4f\x18\xe6\x5d\x61\xf6\x7c\x5c\xa3\x4e\x20\xf1\xc0\x35\x92\x23\x58\xc1\xb5\xd3\x5c\x71\x64\xf2\x57\x3f\x1a\xa8\x34\xb1\xb6\x9c\xca\xab\xbc\x11\x9a\x3f\x4d\xba\x59\xd9\xc4\x8b\xc0\x34\x9a\xce\x30\x8a\xa1\x2a\x96\x91\x5c\xb5\x7a\x95\x83\xf3\xa6\xd0\x41\x57\x07\x0e\x46\xd9\x87\x4e\x8e\x19\xe1\x49\xb1\x68\x1b\xda\x93\xee\xfc\x2e\xcf\x70\x5c\x39\x45\x46\x10\xf8\xd0\x09\x34\x8c\xa8\x04\x5e\xc2\x5e\x2d\xa9\x1d\x7b\x9e\xc2\x2f\x17\xe1\x93\x74\xad\x86\x8b\xde\x61\xb4\x70\x80\xc8\xae\xf6\x65\x66\x5d\xa6\xb5\xe4\x22\xcc\xfc\x89\x87\x7d\x45\x63\xc6\x80\xa4\x73\x20\x6f\x42\x69\x56\x29\xa0\xea\x43\x6d\xe4\x70\x15\xde\x2a\x6b\xbe\x66\xb3\x30\xed\xe2\x51\xda\x50\x0e\x78\xb5\x3a\x79\x15\x37\x52\x34\xa2\xfa\x3c\x07\x60\x70\x81\x62\x47\x5e\x27\xf3\x36\xbd\x39\x9c\x79\x00\x09\x0e\xbe\x9b\x00\xb1\xa9\x04\x00\xb3\x4c\xf4\xa1\x75\x7a\xc6\x62\xf7\xe0\x1d\xd7\x46\x82\x6c\xd6\xf7\x1e\x7c\xf5\xaf\x49\xa6\x9d\xc1\x9d\xac\x38\x0a\x4f\xb0\x98\xde\x04\xa5\x3d\x18\x9d\xe7\x0b\xb2\x15\x67\x60\xb5\x91\xb8\x27\x2c\x45\x30\x84\x6c\xe5\xa3\x26\x80\xdf\x0d\xfb\x20\xc9\xc7\xb4\x45\x35\x93\x4d\xc0\xf6\xb2\x90\x05\x84\x81\x24\x1e\x14\xe1\xe5\x75\x57\x0c\xe1\xa0\x38\x51\x2b\xaf\x67\x82\x4a\xd6\x0e\x60\xbc\x8b\x68\x11\x56\x3f\x18\xc6\xe1\x74\x03\xb1\x32\xd1\x0d\xd5\x74\x9a\x6e\x9d\x6a\x30\x6f\xae\xa2\x34\x7f\x7d\x50\xff\xcd\x16\x6a\x96\xcb\x1f\x7b\x0c\xb6\x90\x2c\xf1\xbc\x0f\x34\xc4\x4a\x24\x30\x52\x92\x8b\x58\x8d\xa5\x68\x5b\x3b\x52\x27\x5c\xd7\xd5\x76\xe3\xae\xbb\x6e\x3b\x7c\x96\xa2\xab\x5f\x3d\x83\x9e\x7d\x6f\xbc\x5d\xaf\xef\x8e\x9d\xc2\x57\x6e\xdb\xe0\xe4\xd1\x69\xac\x1a\x2f\xe5\xac\x44\x7e\xaf\x24\xd6\x65\x70\x75\x1c\x89\x32\xca\x8b\x08\x10\x87\x42\x0a\xac\x30\x16\x2c\xa4\xda\x09\x12\x22\x10\x60\x1b\xb6\xb8\xb3\xed\x99\xde\x8d\x2d\xef\x5e\x14\xee\x8f\xa7\xcc\xd7\x04\x50\xa0\x0b\xb1\xfa\x05\x40\x9e\x37\x12\xb3\x6e\x59\xe4\x46\x68\xf5\xee\x6a\x19\x1f\x95\xd8\x0a\x09\xed\x1d\x3d\x19\x15\x8e\x8f\xc6\x9d\xdc\xba\x5e\x51\x66\x7d\x41\x86\x35\x3d\xb8\xf2\x55\xbc\x13\x24\x41\xf3\x9e\xe0\x50\x05\xf1\x17\x1a\x0b\xce\x80\xee\x07\x65\x7a\xaf\x14\xfd\x80\x13\xfa\x09\xf5\x39\x6b\x23\xe3\xab\x6a\x56\x75\xc8\x62\xa4\x07\x18\xe9\xa6\x8f\x92\x4e\x89\x81\x66\x81\xe1\x8e\xa8\x06\x8d\x20\xac\x3d\xd9\xf6\xa8\x91\x08\x2a\xb4\x04\x6a\xf9\x62\x47\x1b\xbc\xdc\xb1\xae\x3b\xa7\x64\x65\xbf\xaa\xd8\x93\x73\x06\xb4\x82\x39\x62\x10\x88\x14\xe5\xd1\x69\xd8\x20\x64\xbb\xa7\x23\xd0\xf3\xad\xc5\x2a\xb5\xa7\xd1\x05\xa6\xc4\xaa\x46\x0b\x70\x01\x51\x41\x5d\x28\xcb\x7e\x09\xa8\x2f\x54\xeb\xe0\xf2\x34\x49\x3f\xcb\x94\xef\x9b\x3e\xcc\x62\x27\x38\x81\x7e\x1e\x67\xc0\x80\x6c\xa6\x3b\x16\xde\x10\xd0\xf6\xb0\x8e\xbc\xca\x19\x88\x4d\x02\xf3\xbd\xe9\x4b\xa9\x62\xb2\xcd\x2d\x8a\x22\x8b\xf5\xed\x66\xe5\x11\xd5\xc4\x7b\xd8\x46\x2a\x42\xdc\x36\x0b\x0c\x8b\xb8\x03\xa5\x85\xa2\xda\x25\x22\x95\x73\x0f\x85\xce\x66\xeb\x1d\x5d\xf2\x5b\x9e\xe4\x5b\x2f\x10\x6f\xfd\x2a\x6f\x6b\x96\x1d\x06\x0a\x3e\xf4\xb4\x77\x74\xce\x02\xf0\x65\x4f\x1b\xbf\x54\x89\xbd\x4f\x40\x8f\x03\x53\xac\xd6\xbc\xf0\x98\x3e\xd1\xab\xaa\xcf\xf7\x4b\x52\x95\xb9\xf7\xe6\x13\x06\xa9\x19\xde\x47\x5d\x60\xbc\xd8\x48\xda\x1c\x98\xb4\x85\xaa\xac\x4d\x33\x8f\x5b\x7d\x04\x8a\xac\xba\x70\x1c\x62\x4f\x36\x73\x4f\xc5\x13\x75\x95\x20\x30\x93\x0c\x4e\x66\xe7\x94\x02\xd6\x3c\xae\x07\x22\xac\x21\x37\xc4\x25\x8c\x60\xa7\x36\x25\xc3\xa0\x45\xf6\x38\xde\xdf\x79\x91\x36\xd8\x03\x06\xde\x11\xcf\x0b\xc2\x5f\xfa\xa1\xdf\x54\xfc\xcd\x7e\x89\xbd\x7c\xfe\x1e\x78\xdd\x05\xc9\x32\xc4\xdb\x07\x70\x23\xd8\x14\x57\xba\xd7\x19\x37\x0a\x99\xab\xfc\x93\xb6\x33\xc6\x16\xb8\x01\x9c\x03\x73\x16\x18\x97\xda\x17\x4c\x35\xbd\x8a\x17\xb1\x65\x3f\x82\x3e\xb9\x45\xfc\xa8\x1a\x8d\x5c\xd5\xb1\x7a\x1c\xd8\xb8\xf3\x4f\x59\x8e\xd2\xc6\xa5\x2b\x55\x1c\xf4\x06\x2c\x60\x64\x25\x6f\x88\x47\x98\x69\xa2\xf0\xba\x26\x52\xc3\x60\x8d\x06\xb0\x43\x1b\xe3\x4f\x4f\xcd\x32\x8c\xda\x09\x23\xc9\x3c\xb9\x0a\x1c\x0f\x12\xf6\x1a\x65\x49\xac\xde\x0a\x26\xe3\xf9\x58\x72\x38\xf7\xa6\x25\x97\x96\xe3\x00\xf1\xae\x88\x9e\xae\x0d\x30\xdb\xa5\xf2\x6e\x72\xc9\xdc\x40\x5f\xf8\x79\x33\xa6\xd6\x6c\x9f\x9c\x9e\x34\x2f\xc7\x92\x2b\x63\x12\xce\x50\x27\xb9\xb7\xea\x07\x44\x7a\x98\xb7\x2a\x7f\xa2\x15\x41\x5f\xc3\x6b\xa5\x8b\xc0\x78\x99\x95\x06\x5f\xb0\x8c\x36\x05\xc4\x80\x7b\x55\x9e\x95\x79\x2e\xc0\x5b\xd3\xb0\x6c\xd5\x76\x5a\xe6\x2a\x9a\x2a\xe2\x9b\x76\xe3\xba\x95\xb3\x4d\xf6\xdd\xe9\x15\x33\x3b\x55\x9f\xeb\xe6\x8b\x16\x77\x79\x5e\xf4\x8a\xa4\x3b\x71\x5e\x13\xdd\xf0\x75\x47\xef\xb4\x17\x7f\xb3\xc5\x7e\xaa\xfa\xad\xa7\x89\x55\x36\x69\x75\x4b\xd2\xd6\x01\x5f\x4a\xe7\xb7\x40\x24\x95\x20\xe3\xc9\x79\x1f\xa8\x6a\xff\x7e\xa8\x73\x4b\xbd\x68\xb2\xa2\xf1\xfd\xe5\x2a\x97\x95\x46\xfd\x9b\xe8\x4e\x00\x58\x0a\x8d\xf7\x1f\xe9\x3e\x33\x2d\x7f\xf8\x82\x18\x84\x99\x47\xd0\x87\x9b\xa2\xb0\x04\x6b\xfa\xc3\xe4\x86\xad\x40\x76\x35\x23\x1c\x5a\xd7\xe2\x5d\x27\xc7\x65\x26\x0f\x05\x78\xf2\x25\x01\x20\xd6\x60\xc1\xa5\xb8\x21\xdc\x8d\x5a\xe7\x0c\xc1\x42\x30\x93\x8d\x89\x26\x9c\xa1\x8d\x5c\x69\x96\xc0\x07\x96\x00\x83\xef\x26\xa0\xfc\x86\x95\x61\x66\x16\x8e\x04\x67\x12\x78\x8b\xe7\x15\xce\x9a\xe0\x71\xd8\xe9\xdb\x6c\xf6\xf0\x19\xa9\xa7\x0a\x84\xd4\xb6\xae\xe0\xbc\x48\x5e\xa5\x80\x99\xc0\xee\x96\x65\x0b\x88\xbf\xcc\xdb\x49\x5b\x62\xb4\x97\x40\x4e\xa3\xbb\x49\x59\x06\x8a\xb6\x2a\x27\x12\xa0\x38\xad\x95\x7c\x35\xf0\x62\x83\xe0\x30\x13\x00\xd2\x3f\xf7\x91\x61\xaa\x36\x41\x08\xb5\x2b\x20\xb7\xae\x17\x2c\xba\x18\x59\xe8\x81\xf5\x21\x2c\x63\xe3\x01\xbd\x50\xd1\x3c\xed\x03\x40\x85\x77\x5b\x21\x32\xfa\x5f\xfb\x6c\xc2\xb4\xfc\xcd\x36\x09\xcd\x95\x3f\x02\x6f\x9e\x37\xfa\xd7\xcf\x7c\xb4\x5d\x91\xbd\x1f\x82\x1a\x70\x10\xcc\xbf\x63\xd7\xe1\xb5\x18\x7e\x74\xd2\x8d\xd1\x67\x2d\xb7\x53\x77\x9f\xdf\xee\x95\x34\x28\xc1\xb7\x0a\x6f\x77\x7c\x1d\x77\x42\x5f\xc7\x6e\xb0\x08\xcf\xe2\x65\xbe\x9e\x1d\x01\x11\x3d\xd2\xaa\xc9\xd0\xb0\x37\x6c\x48\xfa\x6b\x03\x66\x82\xc2\xf6\x8b\x5d\xf3\xdc\x1e\xf3\x0b\x89\x4b\x87\x69\x51\x55\xba\x40\xc0\x79\x9b\x49\x09\x1b\x73\x62\x59\x30\x38\xc1\x18\x76\xd9\x08\x4f\x1f\x17\x4f\xb3\x37\x7c\xbd\xbc\x1d\x42\x44\xd4\x13\x6c\x3a\xed\x68\x80\x0d\x17\x39\xce\x62\x50\x65\xcc\xf7\x41\xc8\xdb\xce\xd9\xaf\x5e\x0a\xa0\x09\x89\x0f\xd5\x33\xb7\x93\xf6\xb7\x87\xcd\x3e\x5e\x03\x8d\x94\x68\xd3\x9d\x2e\x70\x39\xb4\xba\x99\xd3\x42\x94\x93\x2b\xf1\x55\x22\xff\x5f\xec\xbd\xb7\x12\xf4\x7a\x8e\xe5\xf9\x40\x34\x28\x93\xc2\xa4\xd6\x5a\xd3\xa3\xd6\x5a\xf3\xe9\x37\xaa\x6a\xb6\xeb\xae\xb1\xd1\x3d\x31\xdf\x44\x5c\xa3\xdc\x34\xe0\x64\x02\x38\xf8\xe7\x01\x7e\xd2\xc6\x56\x36\x5d\x31\x2b\x93\xaa\xb6\xcd\xa9\x6e\x6e\xd3\xfc\x53\x90\xe5\xc8\xd0\x46\x0d\x20\x3e\xc2\x5e\x86\xde\xf7\xb5\xbb\x32\xe3\xc6\x3e\x02\x43\x8e\x67\x57\xce\x0a\x13\xde\xfc\x4a\x3b\xf9\xbe\xab\x1e\xad\xf0\xe2\x36\xa6\xe2\xd6\xad\x2a\xfc\x5d\x46\x3f\x49\x18\x73\xbc\x8f\x3a\x20\x81\xbf\x38\xcf\xd8\xfd\x42\xe0\x21\xd0\x95\xa2\xf9\x34\xd9\x1c\xd0\xe0\x60\x5e\x19\x4e\x79\x71\xd1\x96\x52\xec\x96\x06\x52\xa0\x71\x57\x52\xba\x95\xce\xdb\xb5\xcd\x49\xc3\xf6\xb0\x3c\xd6\x1c\x1a\x3e\x99\x7e\x06\xf1\xdb\x75\x78\x6d\xeb\x71\x30\x80\x82\x41\x4f\x00\xb0\xd3\xf9\x17\x62\xde\x91\xf1\x51\x24\xef\xed\xfe\x89\x1a\x66\xd1\x10\xd4\x1e\xde\x7e\xe2\xd1\x64\x87\x33\xe4\x75\xba\x47\x2b\x6b\xa5\x73\x0f\xb8\xbd\x8c\x92\xa7\xc1\xe7\x1a\xae\x84\x55\x21\x64\x03\x5b\x2f\x57\xbf\x6d\xef\x9c\xb6\x2d\x88\xf7\x35\x88\x73\x8e\x5c\x34\x99\xa0\xb2\xe6\x21\xa3\x35\x1d\xda\xa0\x32\x1b\x82\x09\x0e\xd6\xb6\x96\x60\xb5\xc1\x42\x78\x6e\x43\x9d\x8a\x60\xc1\xf6\xf8\x02\x24\xab\x22\x1a\x6c\x6b\x8d\x4b\x9d\xf6\xa9\xa6\x5a\x68\x5c\x76\x9e\x25\xe4\x09\x2c\x36\x64\x86\x5b\xcd\x69\xfa\x66\x22\x78\x3f\x69\xfc\x28\x81\x7f\xfe\x30\xff\xa8\x6c\x3c\xfe\x66\xb2\xb1\x4a\xfe\x7a\x9a\xfa\x5f\x5c\x60\x97\xfc\xc6\x34\x53\x0a\x4e\x65\x90\x7a\xe0\xef\x98\xe2\x1f\x25\x6e\x19\x9f\xb7\x97\x00\xf9\xad\xf5\xc1\x44\x55\x9d\x2d\xfc\x11\x9d\x67\xa7\x56\x00\x5d\xf1\xaa\x53\x14\x66\x61\x8a\x12\x3b\x64\x71\xc0\x5e\xaf\x1a\xa6\x6d\xe7\x21\x63\xd3\x2d\x4d\x4f\xb8\x05\xa1\x97\x04\x9e\x98\xc6\x02\xf1\x7b\xcb\xc4\x61\x66\x5e\x55\x49\x92\x00\x4e\x35\x92\x69\xd2\x3c\x55\xa1\x9f\x17\x4c\x9c\x6a\x48\x57\x33\xec\xd5\x6a\xdd\xe0\xa6\x43\xf3\xf5\x86\xbb\x23\x14\x91\xc2\x2f\x9c\xfc\x3a\x93\x3b\x04\x1f\xa4\xba\xfd\x78\xa5\x59\xaa\x94\x91\xab\x30\x7c\x53\xd3\xca\xe7\x71\xc6\x9b\x8d\x87\x3f\xb9\x3f\x6b\xac\xc1\x61\x33\x20\x42\xfa\x19\x3a\x58\xc1\xa8\x30\xeb\xf5\x12\x71\xee\xd9\xb4\x72\xab\xa2\x76\x8b\x6b\xfe\x59\x47\x84\x40\x67\xa9\x65\xed\xca\x5a\xc9\x92\xa4\xb2\xee\xb1\x3a\x7b\x14\x08\x96\x7d\x26\x35\x47\x31\xcc\xd3\xb5\xbd\xdb\x3a\x2b\x06\xd3\x74\x5f\xb3\x36\xf3\x05\x15\x04\x30\x21\xcf\x44\x84\xc8\x8c\xd0\x53\x4b\x92\xbf\xf6\xb0\x9f\x31\x27\x9f\xcb\x6f\xf1\xbd\x6c\x32\x98\x32\x15\xf3\xe2\xc9\x3d\x77\x71\xb2\x6c\x7b\xb8\x68\xd4\xa0\x57\xcb\x26\x58\xb7\xe5\x2b\x66\x29\x38\xa7\x49\x05\x4e\x1c\xdd\x71\xd2\x74\xd4\x66\x3f\xac\x60\xad\x80\xaf\xec\x5f\x24\xe7\x6d\x0f\x42\x20\xd2\x72\xa5\x19\x7f\x68\x5e\xb2\xcf\xd6\xee\x7a\x4b\x41\xd8\x0b\x45\xad\x6e\x0b\x55\xcf\x10\x43\x8d\x3f\x82\x74\x0b\x0f\xbf\xfa\x7a\x00\xa5\x93\x6f\x30\x5a\xa8\x8e\xe4\x53\xa0\x2d\xf6\x31\xa1\xf9\x8d\xb4\xfb\x40\xfe\xde\x86\x24\x0a\x8f\xf4\x8f\x8a\xba\x11\x68\x08\x89\x35\xdf\xba\x38\x23\x69\x55\xd2\xe3\xa3\x09\x6b\x2e\x5f\xca\x9e\xa2\xce\x3b\xe7\x80\x03\x3b\x70\x77\xf2\x91\x33\x43\xad\x5e\x27\x8d\xfd\xd1\xc8\x7d\xbb\x1e\x60\x4d\xa4\x87\x23\xd4\x90\xfe\x23\x5b\x10\x0a\xce\xee\x93\x8a\x68\xe2\xca\x5f\x74\x44\x80\xda\x4b\x7d\x07\xc6\x8e\x66\xeb\x29\x26\x4a\xf7\xac\x68\xcd\xce\x2d\xd1\x69\xb4\x96\xfb\xdd\xa1\xc7\x6d\x41\x69\xc9\xb8\x02\xcd\x64\x9b\xc5\x8b\x07\x5c\xd1\x24\x73\x32\xb0\x23\x19\xbe\x45\xad\xf9\x97\x7b\xca\x22\xc9\x14\xcb\x18\x1c\x9f\x02\x80\xf8\x72\x8c\x41\xfd\xd3\x13\x7f\x57\xdc\xc0\x06\xbe\x9d\x1a\xf4\x9f\xee\x66\x7f\x33\x19\x59\x08\xff\x4e\x44\x92\xda\x20\x84\x8e\xab\x45\x81\xda\x60\x24\xf8\xb5\x09\xcc\xe7\x26\x0a\x8e\xe1\x8b\xa5\x65\x79\xd8\x99\xf9\xc4\x29\x8a\xcb\xaf\x33\xb9\x7c\x40\x67\x27\xca\xb2\x59\x96\x57\xc0\x34\xf3\xb3\x4f\x4c\x7f\xee\x78\x81\xa4\xda\x6d\xe4\xf3\xbe\xfd\xc0\x65\x83\x63\x80\x76\x18\x4d\xab\x01\x70\xbf\x2f\x5f\xde\x24\x1e\x5f\x81\xc0\x4a\xe3\x47\xa2\xe0\x0e\x58\x26\x60\xb9\xbc\x2c\x97\x4a\x52\x6c\x87\x1d\xc8\x30\xc5\xd6\x63\x0f\x5a\x0d\x4a\x65\xcb\x30\x44\x2b\x89\xd4\xc4\x5e\x6b\x4f\x90\xbf\xaa\x91\x2c\xf2\x43\xfa\xdd\xef\xfc\x7d\x6e\x97\x53\xe2\x7c\x91\x49\xdb\xb0\x0e\x4b\x72\x00\x61\x4e\x98\x92\x7f\xe5\x25\x96\x9e\xe8\xf2\x32\x8b\xe5\x87\xaa\x1c\x0c\xcc\x79\x56\xd4\xc2\x2d\xcb\xf2\xbd\x3c\xc2\xbc\x30\xb0\x08\x3f\x42\xed\x7d\x84\x55\x3b\x45\xbd\xfc\x75\xad\x09\x75\x43\x77\x70\xec\xcf\x3b\xaa\x41\x94\x45\xdf\xd6\x19\x60\xac\xba\x14\x9c\xad\x0b\x71\x1e\x4a\xd7\xbb\x45\x2f\x94\xc7\x8c\xde\xc8\xbb\xfb\xfc\x96\xfb\xf2\xae\x56\x1b\xb6\x0f\xdb\x60\x50\xf2\xf7\xe5\x32\x8c\x09\xdb\x61\x97\xcf\xee\x66\xb8\xeb\xbc\x7b\x82\x09\x59\x05\x08\x78\x29\xdd\xb4\x97\x53\xb5\x22\x1a\xf4\xf8\x6b\x59\x4f\xfb\x4d\xa0\xc6\x06\x8e\x48\x73\xc6\x5c\xa6\xe2\x2c\xad\x6f\x1a\x75\xbf\x7a\xb5\x07\xcf\xe4\xe6\x2b\xbf\x8d\xfe\x47\x77\xf8\x1d\xad\x01\x59\xb2\x33\xc1\x73\x8d\x3e\x4f\xbc\xb4\x84\x40\x91\xb0\x44\xed\x8b\x14\xc9\xa1\x75\x39\x13\x57\x9f\x41\x70\x43\xe5\xf4\x65\x15\x07\x81\x9b\xe2\x0b\x3f\xd3\xe1\x17\x68\xd6\xf9\x0f\xdd\xa3\xc0\x80\xec\x92\x02\x0a\xf5\xb1\x79\x90\xee\x2b\x46\xc5\xb9\x23\x94\x75\x36\x48\x20\xd2\xf7\x3c\x33\x60\xa8\x40\x83\x32\x44\xe4\x18\x26\xe6\x6f\xf7\x3b\xda\x87\x2e\xf7\x85\xc7\xf8\xd0\x08\xec\x8c\x99\xbe\xda\x3e\x91\x6a\x4a\x90\xa3\xcd\x75\x0f\x58\x92\x84\x14\x59\x7d\x06\x03\xfe\x5e\x59\x28\x01\xd0\x63\x02\x57\x16\xb8\x9f\xfd\xc4\x64\xf8\x54\x56\x81\x1d\x75\x03\x84\x7b\x8f\x3e\x28\x55\xa8\x1a\xe1\x06\xa8\x17\xe9\xc5\x34\xdd\xfb\x67\x59\x3e\x8a\x80\x11\x7f\xfa\x61\x64\xf9\xbb\xbd\x76\x8e\xcd\x5f\xb9\x2c\x9b\x0f\xf1\xb1\xe5\x59\xe8\x6f\x8d\x9f\x34\xc4\xbd\x81\x4b\x17\x43\x0d\xc5\xac\x9e\x11\xa1\x17\xc8\x8d\x76\x18\x7c\xcb\xe6\xe8\xdc\x2b\x48\x00\x9b\x77\x45\x7c\xac\xdf\x84\xf5\xac\x57\x97\x29\x4f\xfa\xd5\x30\x97\x77\x98\xfd\x90\x52\xa8\x75\x28\x45\x4d\x14\x62\xbc\x4e\x40\x87\x8e\x35\x11\x7b\x09\x7d\x48\x8a\x24\xba\x8f\x9b\xa6\x11\x11\x5c\x77\x6d\xb0\x69\x87\x02\x1f\x7e\x33\xe1\xeb\x70\x02\x0b\x53\xf4\x0c\xdb\x30\xab\x76\xc1\xce\x80\x6e\x13\x3b\x32\xba\xb2\x11\x92\x86\x2b\x0e\x9c\xa7\x51\x96\x6d\x19\xbd\x41\x1c\xcf\x11\x30\xf5\xf1\x77\x1a\x56\x62\x64\x47\xd7\xa3\x03\x89\x94\x2f\x09\x00\xe4\x1c\x62\xca\x05\x4a\xe0\x5d\xd0\xd8\x0f\xaf\x91\xfe\x92\x28\x4a\x78\x25\xa3\x3d\xe9\x0f\x29\xee\x6a\xc8\x0c\x32\x0e\xc9\x4f\x57\x7f\xe2\x0c\xb2\x7a\x65\xf7\x74\xb3\x88\xfb\x6b\xd7\x0e\x7b\x0c\x0b\x8f\x75\xb2\xaf\xbd\x2c\x55\x49\xdf\x49\xe8\x96\xc5\x0f\xe0\xaf\xcd\xf0\xd0\xe4\x21\x45\x31\x9c\x56\x92\x6a\xbc\x23\xf1\x51\xef\x6e\x10\xa9\x45\x2c\xeb\xb3\x18\xb3\x42\x2c\xee\x90\x0e\xc7\xf6\x9e\xfe\x09\x9e\x54\xa4\xbc\x6e\xb5\xb4\xb2\x7f\x07\xbc\xab\x50\x81\xed\xa7\x32\xc6\x58\x0f\x01\x32\xc7\x89\x4e\xb5\x8e\x0d\x74\xfe\xea\xb2\xb3\x73\xa0\x12\xc9\x32\x66\xe5\xb4\x71\x6c\x96\xaf\x6a\x7b\x92\xcf\x86\xef\xeb\xc3\x34\x78\xa0\x10\x9f\xf8\xe1\xb9\x0e\xe6\x9a\x96\x7f\xf3\x04\x80\xe3\xa8\xf0\x17\x89\x5d\x3d\x5d\x91\xe3\x97\xe7\xdd\x5f\x1a\x45\xf6\xde\x22\x7d\x3c\x88\x7c\x9b\xfe\xc4\x43\x0a\xd4\x09\x48\x47\x8b\x29\xd9\xf3\xb0\xea\x4a\xa3\x35\xeb\x0c\x4e\xe0\xe1\x02\xeb\x46\x78\xfb\x15\xf8\x4e\xe2\xea\x26\x5b\x62\x63\x84\x5f\x35\x08\xa6\xb8\xf3\xcc\x72\x2b\x97\x09\xe3\xf1\xc8\x1e\x35\xd1\xb5\x7a\xab\x37\xa3\x90\xf6\x74\x97\xcb\x3b\x9b\xef\xe9\x74\x35\x4f\x1c\x68\xc1\x2d\xcf\x69\xed\x10\xb4\x1f\xaa\xc9\xe8\x06\x19\x2b\x9c\x70\x18\xa8\x47\x89\x92\x86\xb1\x50\x6e\x80\x15\xb5\x4a\x8e\xef\xa8\xcc\xd7\x31\x0a\x9c\x56\x9c\x48\x1e\x9d\xd3\x92\x0e\x70\x1e\x4f\xd6\x93\x0e\xb3\xee\x9b\xb2\xe7\x70\x01\xe2\xe6\xbc\xe4\x19\xbf\xfc\x90\x9f\x58\x54\x35\x5a\xb0\xf4\x8b\x71\x4c\x20\x27\xd2\x3f\xff\x84\xd2\x4c\x90\x50\x3c\x9c\xbe\x8f\x4d\xdf\x90\xee\xc7\x58\xb9\xc2\x92\xed\xab\x8c\x72\xef\x18\x30\xb8\xcc\x9d\xcd\x07\xcb\xe2\x55\x11\xc8\x2d\x59\x03\xc7\x89\x02\x50\x6a\xbe\xf0\xf0\xdd\x31\xbc\xc7\x70\x80\x9c\xd1\xc0\x2e\x02\x37\xfd\x55\xa4\xdd\x6d\xd4\xcd\x7e\x3a\x5c\x49\x20\x75\x73\xa7\x7e\x58\xe1\x41\x64\x88\x60\xe4\xfd\xc5\xbb\xc2\x99\x67\xe7\x30\x74\xba\xae\x6d\xef\x2d\xce\x0c\xae\x6b\x01\x81\xc5\x45\x11\x39\xaa\xa5\x07\x55\xd1\x76\x4c\x63\x1f\x99\x45\xd4\xe4\xed\x19\xf9\x67\x3b\xef\xd2\xfc\xcd\xe6\xc8\xc6\xf8\xf7\x1c\x39\x1c\x1b\x0f\xf1\xfe\x03\x82\x49\xc6\xa5\x91\xb1\x5d\xc9\x57\xc8\x7d\x16\x9b\x91\x58\x3f\xb1\x3d\xb0\x2a\x22\xcb\x31\xce\x9f\xd5\x23\x16\x0c\x49\x5f\x18\x46\x17\x0e\x49\x5b\x18\xa6\x98\x16\xe3\x00\x7c\x3d\x43\x16\x3b\xf8\xaa\xe7\x45\xb6\x3b\xf6\x5e\x7c\x98\xfd\x78\x66\xae\xb2\xd9\x70\x89\x4a\xc8\xab\xb8\xbc\x62\xc8\xdc\x8e\x5a\xa3\x05\x54\x24\xb5\xbc\x49\x5e\x8c\x08\x97\x17\xe1\x35\x11\xda\xd7\x3f\x82\x34\xb2\xf2\x96\x12\xd3\x48\x9d\x43\x4d\xbe\x5a\x02\x51\x6f\x64\x1a\xbf\x1f\x57\x77\x07\x6c\xe9\x48\x6b\xed\x10\x90\x86\x60\xb5\x15\x0d\x99\x7d\x01\x02\xba\x97\xcd\x4c\xac\xd6\xf2\x6b\x2e\x3c\x9a\xea\xba\x73\x31\x6c\x3e\x35\x94\xad\x68\xb5\x4d\x58\x5a\x4c\x5f\x97\x7c\x62\xe2\x6e\xc3\x22\x05\x4b\x27\xc6\x59\xe1\x34\x97\x01\x43\x61\xff\x2c\xdf\x7a\x30\x86\x15\xf2\x3a\xaa\x8a\x7b\xc5\xac\x06\xe6\x8e\xe2\xc7\x26\x2d\x66\xdc\x84\x6b\xb7\x7a\xc1\x46\xfd\x80\xbf\x81\xfc\x82\x36\x13\xd6\xb9\x0f\xbc\x0f\x18\xed\x9a\x8a\xe4\x85\x34\x15\xeb\xa0\x82\x43\xf2\x48\xa0\xb9\x28\x26\x51\x4d\x7b\x18\xa3\x1f\x18\xd3\x2b\x50\x43\xde\x28\x2d\xb3\x2f\x21\x17\xf3\xb3\xa2\x96\x74\x38\x4a\x98\x61\x28\xa5\x47\x4e\xf1\xea\xf0\x95\x4f\xf3\x5c\x46\x15\x25\xb7\xdd\xca\xcd\x6b\x55\x4c\x14\x8d\x42\xfe\xba\x35\x65\x1f\xd5\x47\x72\x02\xfe\xae\x40\x5d\x0d\x07\xf0\xf5\xf5\x8a\x1c\xe5\x61\x0e\x0d\x72\xbb\x81\xdd\x82\x38\xdc\x92\xec\x31\x3e\x3f\xd1\xa8\x59\xa7\xd5\x93\x80\x86\x09\xd9\x0e\x30\x53\x4e\x3d\x99\xcc\x4e\x09\xa4\x15\x5d\x28\x20\xc4\xeb\x17\xe8\x67\x99\x58\x37\x85\x57\xfe\x23\x78\x8e\x96\x8d\x83\x38\xe1\x88\xb4\x32\x4a\xad\x65\x40\x7b\xb2\x0b\xcd\x05\x87\x7c\xba\x07\xa7\x6d\x20\x03\xbc\x67\x07\x57\x8d\x52\x4b\x6b\x68\x1b\x84\xd5\x19\x76\xa5\x90\xa6\x46\xd6\xef\x80\xe9\x39\x20\xa4\x5f\xfc\x14\x4d\xb1\x36\xd2\xe7\x64\x75\xbe\x08\xe5\x5a\xf8\xcb\xb0\x5c\x76\x88\x09\xcd\x48\xb7\x4f\x02\xee\xf7\x8e\x31\x73\xc8\xea\xe0\x3a\xee\xfc\x2f\x5a\x79\xb4\xe0\x6c\x76\x5b\x45\x3a\x0e\x8b\xb2\x5b\x93\x5a\xc5\x45\x9f\x23\x01\x39\xa0\x82\xba\x61\x04\x03\x76\x12\xe5\x42\x77\xef\x57\xb4\xcc\xcd\xc2\xbf\x7a\xca\xeb\x9a\xb5\x14\x55\x80\x42\xd6\x32\xc8\xe2\x9c\x7e\xbf\xce\x2e\x82\xe5\x43\xe3\x69\xa0\x86\x92\xa6\x6d\x5a\x69\x5a\x31\x3d\x38\x8a\x36\xff\xb4\xf9\x61\x99\xfe\x66\xe6\x87\xbf\xe2\x18\xa9\xc3\xfc\xc7\xcc\x1a\x45\xd6\x02\xb1\xb4\x1f\x8e\x4a\xc6\x42\xd8\xc3\xd0\x86\xe1\x09\x40\xaf\x36\x22\x59\xc9\x1c\x9e\xae\x1a\x58\x5b\x7c\x47\xf1\xd0\x20\x57\x38\xd7\xa1\x90\xa4\x41\xe8\xfd\xd8\x47\x20\xb3\x90\xad\x6e\xe1\x63\x88\x30\xd7\x53\x09\x62\x76\xf0\xf7\x4c\xf0\x08\xcd\x72\xe2\x4d\xf2\x9b\x90\x60\x59\x02\x08\x0c\x7f\x3f\x69\x1f\xa1\x2c\xae\x11\xaa\xd2\xc4\xe5\x09\x65\x25\x64\x62\xd1\xfd\xc9\x34\x39\xe5\x6a\xe3\x51\xe1\x55\x61\xf1\xba\x6c\xc7\x09\xdc\xe8\x4a\xfe\x22\xa2\xa2\xec\x67\x2f\x39\x70\x19\x13\x3d\xd9\x1f\x83\xaa\xa6\xfc\xa7\x18\x37\x44\xb3\xa2\x78\xe1\x87\xe5\x5e\xef\xc5\x73\x2a\x3f\x87\xc9\x2f\x26\x4d\x49\x32\x33\x75\x39\xf3\x1b\x63\xa0\x03\x4d\xeb\x69\xc0\x58\xc5\xda\x91\xb8\xb7\x83\x13\xdb\x71\xd8\x74\x52\x66\xd5\x95\x9c\x64\x39\xa6\x95\x9d\xa6\x09\x74\x2a\x8b\xe2\x22\x58\x63\x3a\x97\x48\x1d\x35\x6a\x17\x3a\x6c\x7b\x17\xf2\xaa\x50\x25\x3e\xbb\x86\x0d\x0f\xdf\xd4\x01\x03\xfc\xb4\x54\xeb\x25\x18\x8c\xf3\x88\xc1\x5f\x31\xdd\x6f\x17\x7d\x50\x10\xdd\xe2\x7c\xf5\x08\x2a\x35\x41\xa6\x09\xfc\x31\xb3\x91\xf5\xa6\xf1\x44\x65\x46\x6a\x71\x54\x82\x34\x45\x2b\x9a\x11\xb2\x4f\x5d\x34\x89\x92\xd6\x9c\x4c\x71\x49\x4d\xad\x72\xcf\xbf\x87\xe3\xf6\xc5\xea\xb9\x82\x7d\x88\xb2\xe6\x66\x75\x4e\x6a\x41\xab\x03\x47\x0e\xbd\x56\x75\xf6\x9f\xfc\x9a\x0a\xfa\xa3\x7a\x2a\x76\xa0\xd2\x2e\x18\x44\x1d\x99\x6c\xb9\xa3\x59\x47\xb9\xb9\x80\xdd\x9e\x03\xf6\x7c\xe1\xd3\x85\x95\x7f\x5c\xb1\xec\x4a\x23\x2b\x79\x97\x76\x76\x92\xd6\x79\x27\x03\xbf\x59\x2b\xb1\xa0\x2f\xed\xe9\x6d\x93\xba\x90\x25\x24\xc2\x19\x85\x28\xdc\xd5\xd6\xaa\xad\xae\xbb\x1b\xa2\xed\xdb\x02\x40\xb1\xac\x59\x59\x5a\x16\x63\x16\xe8\x9a\xd7\x4d\xd8\x49\xd4\x99\x60\xec\xda\x69\xd1\xd7\x80\x7e\xf9\x74\x17\x34\xc4\xd8\x3a\x5d\x0b\x28\x8b\x2f\x53\x76\x1a\x35\x85\xe8\x14\x2d\x78\x70\xd1\xba\x6c\x83\xf7\x19\x20\x88\xd7\x8c\xe8\xcf\xc4\x30\xd4\x9c\x27\xcf\x82\xe9\xd3\x0e\xe7\x45\x89\xc0\x28\x43\xc2\x25\xf1\xdc\x74\x3e\x60\x5d\x9f\xa6\x90\xec\xbb\x9d\x5f\x68\xca\xdd\x6b\x10\xdf\xe1\x81\x7b\xd1\x1b\x7b\x10\x03\x09\xb7\xfd\x89\x8b\x9b\x3a\xc5\xbc\x4f\x52\x81\x32\xb8\x8a\x33\x3a\x10\x97\x3e\x40\x25\x53\xfb\x19\x3f\xee\x8c\x49\x43\x28\xdf\xb8\x8e\x0a\xcc\x30\x71\x54\xdc\xb4\x51\x9a\xbd\xe6\x6e\x96\xf2\x2a\x12\xde\xc7\x95\x72\x3c\xe3\x3c\x27\x2e\x40\x62\x65\x48\xaf\xaa\xab\x44\x36\xc0\xd8\x3f\xad\xfc\x03\x39\x18\x84\x29\x05\xcd\xee\xd8\xba\xac\x30\x5a\x91\xbd\xef\x5b\x25\x78\xca\x7d\x3d\xa0\xe8\xab\x9b\x45\xd5\xc9\xc9\x09\x02\x44\xbb\x90\x95\x2a\x35\xf9\x72\x2b\x9a\xd6\xe9\x34\xcd\xa7\x61\xc8\x05\x66\x8c\xff\x70\x57\x5f\xfe\x66\xf3\x74\xdf\xfc\xf5\x84\xd5\x3f\xbb\xba\xe5\xe9\xc4\xeb\x26\xcb\xf8\x79\x14\x67\xa4\x63\x48\x1f\x42\xe5\xb6\x6c\x5b\x6f\x00\xfd\x08\xd4\xa7\x1e\x17\xd8\x5c\x15\x48\xf7\x2d\x20\xf0\x2d\x3e\x5f\x98\x7c\x84\x92\x25\xb6\x77\xcb\xf8\xea\xec\xaf\xab\xe7\x2b\xf2\x38\x3a\xa8\x4e\xe8\x1f\x7a\x40\xbd\x51\xc2\x23\xa6\xc9\x77\x0e\xe0\xbf\x1f\xf5\xfb\x86\x67\xe8\x78\xe5\x2b\x9c\xdf\x59\xfd\x26\x6d\xdc\xaf\xe4\xc1\x6b\xf7\x3a\x0a\x2a\xa4\xb2\xae\x11\x88\xae\xfe\x15\x12\x35\x39\x39\x78\xaf\x64\x1c\xa5\x9e\xab\x2c\x47\x06\x3d\xfd\xf0\x10\x72\x32\xab\x3e\xff\xc1\x9f\x82\x70\xbe\x8f\x53\x20\x4a\x5c\x42\xbc\x71\x4f\x59\x2b\x94\x0f\x0d\x2c\x40\xcf\xb2\x1c\x88\x35\xc5\x6a\xc0\x25\x9b\x99\x85\x91\x2a\x67\x4f\xc4\x03\xed\x61\x1b\x4c\xca\x36\xf1\x5c\x4d\xa8\x62\x0f\xb4\x20\x9d\x63\xad\xaf\x83\x0e\xc1\xec\xe3\xe6\xba\xcf\x11\xe9\x55\x8a\x46\x44\x39\x90\x80\xda\x55\xa8\x5a\xf9\x0a\xd0\x3a\x8a\x7d\x63\x37\xe4\xe5\x24\xe3\xbc\xa1\xe8\xd0\x49\x8c\x6e\x8c\x03\x06\x03\x0b\x44\x3c\x87\xa4\x2f\xd7\x24\x6f\x34\x40\x28\xd0\x18\x34\xea\x3d\x86\xbd\x37\x83\xa8\xd1\x13\x8f\x61\x1f\x2b\x6b\x70\x3d\x47\xc9\xdd\xea\xc6\xc5\xc0\x2d\xfe\x65\x2c\xa4\x9e\xf4\xfe\x18\xb2\x17\xde\xb5\xa1\xc7\x56\xa9\x05\x4a\x2b\xf0\x26\x45\x6f\x9d\x44\xb7\xd7\x46\x77\xc6\xc7\x6c\x58\x85\x5d\xb7\x5c\x17\x22\x87\xc5\x3e\xcd\xee\x09\xcb\x93\xf4\x11\x8b\xa1\xf7\xeb\xd8\x5d\xb4\xef\xdf\xcd\xc7\xca\x67\x81\x4b\xf7\x73\xee\xd8\xa3\xe1\x0c\x22\x4a\x7b\xac\x12\xd2\x82\xf6\xba\x48\x75\x44\x18\xe2\x3b\xec\xf5\x5a\x5f\x06\xdc\xb0\x69\x13\x45\x45\x55\x87\xee\xdd\x0e\xab\xa1\x6f\xe0\x73\x15\x83\x31\x08\xb3\x61\x6f\xb9\xde\x7e\xd7\xe7\xae\xd2\x1a\xfd\xb9\x6b\xde\x1f\x29\x1f\x7a\xbe\x27\xc5\xc6\x83\xb5\xa2\x0f\xb2\x08\x05\x30\x57\x84\x69\xcb\x09\xb2\xc4\x17\xd7\x42\x57\xd6\x6e\x8c\xa3\xe1\xeb\xee\xd2\x1b\xdd\x4b\x2c\xf9\x10\xd4\x96\x27\x94\xd1\xe6\xa9\x64\x8c\x47\x6f\x4c\xdf\x46\x6a\x9b\xd2\xa3\xf7\xe5\x97\xa3\xf8\x01\xc5\x93\x9b\x59\xaf\xcc\xbd\x0e\x31\x49\xbb\x3b\x48\xa7\x45\xe6\x68\x19\xc9\x7e\xa5\xd7\x05\xec\xb0\x56\x07\x2e\x14\x0c\x4c\x1c\x1a\xf1\x96\x6c\x26\x38\x4c\x3c\x6b\x1b\x7e\x39\xa0\xd5\xba\xfc\xf0\x63\x12\x25\x65\x38\x08\x74\x90\xa9\x37\x93\xb5\xb2\x91\x6a\x57\x0f\x00\x72\x79\x1b\x10\x35\x57\xe6\xfd\x4b\x19\x01\xbc\xcb\xd2\x06\x01\x16\x17\x49\xe7\x09\xc0\x6a\x30\xad\x0a\xcc\x8d\x95\xe0\xa4\x89\xeb\x8a\x0a\x16\x94\x25\xfb\x70\x67\x6f\x52\x81\xb7\xa2\x69\x99\x4f\xe5\x02\x1e\x81\xeb\xfc\xb3\x47\xb3\x97\xbd\xf8\x7b\x25\xfd\xfa\x57\x5b\x24\xac\xf3\x10\x1f\x57\xd9\x51\xa8\x6a\x28\x1e\xb3\x7c\x38\x61\xad\x48\xf4\xc2\x32\x3c\x22\x43\xf1\x39\xb7\x6e\x9a\x96\x9c\x52\x9a\x4a\x83\xc1\xb1\x81\x7a\x95\xd7\x3e\xb9\x73\xeb\x15\xdf\x93\x25\xa7\x88\x34\xc0\xd7\x50\xec\x79\x8e\xa3\xd7\x10\xa2\xaa\xc2\x3c\xb3\x4c\xe6\x0d\xbd\xa2\xb9\x44\x45\x58\xc0\x89\xaa\x54\x34\x93\x6d\xe8\xa1\xc9\xf4\xfb\xed\x30\x81\x82\xa7\xa8\x43\x90\x17\x0c\x77\x52\x7d\xca\x77\x70\x14\xd2\xaa\xe6\x6f\x3e\x2f\x5b\xb4\x2d\x29\xb7\x39\x03\x25\xa1\x6b\xe0\xac\x0d\xff\x55\x85\xd6\x61\x66\x8a\xc1\x2d\xb5\x0b\x07\xf0\x1e\xb5\x41\xcc\xc4\x3d\x8b\xe6\xb6\xd6\xd7\xb5\x68\x4c\x2a\x90\x57\xd8\xc1\x86\x4f\xdf\xa2\x17\x18\x8e\x8e\x8e\xd5\xef\xf2\xc1\x2f\xf5\x81\xe8\x75\xed\xd3\x5b\x65\x21\xfa\xa8\xe6\x19\x45\xad\x9f\x5d\x62\x03\xe2\xe7\x0a\xa6\xed\x13\xbf\xa1\x8e\x2c\xce\xfc\xfc\xc4\xf2\xb0\x11\xe5\x0e\x50\x1d\xe4\x53\xa2\x66\xbf\x8b\x62\x5e\x4a\x12\xf0\x36\x6b\xd1\x4e\x5a\xcc\x4b\x72\x51\xfe\x35\x5a\x06\x08\x26\x00\x78\xae\xe9\xaa\xb9\x76\xe4\x3a\x0d\x15\x32\xc4\x5b\xdb\x82\x01\xd2\x31\x55\xe2\x6f\xef\x5b\xbf\xcc\x39\xf1\xb6\x79\x44\xef\xe8\xbb\x15\xc3\x41\x08\x0c\xee\x03\x0e\xf9\x65\xe7\x5e\x69\x2c\x35\x76\x23\x42\x2c\x3e\x44\x86\xe0\xc6\x54\x8a\x29\xa6\x36\x05\x24\xfc\xdb\x12\x3d\xbe\x5d\xbb\x23\x1b\x95\xe3\xc6\xf4\xf8\x21\x48\x17\xc4\xc2\x14\x6d\x7e\xfe\x6c\xc6\xb7\x55\xc8\xe6\x82\x44\x2d\x78\xc0\xe4\x36\x08\x75\xce\xdd\xf8\x0c\xbc\x45\x1b\x06\xce\x6d\x32\x13\xbb\x68\xd0\x6c\xd2\xfa\x68\xf0\x8d\x96\xc8\xb5\x5b\xce\xcf\x2d\xba\x61\xce\x3b\xf3\x04\xea\x14\x37\x33\xfd\xe4\xc9\x85\x61\x1b\xb4\x3e\x99\x98\x25\x07\xe2\x22\x0b\x51\x7e\x4f\xc5\x40\x23\xe6\x21\xe6\x98\x4e\x3f\xe3\x80\x10\x0b\x46\xcb\xe7\x10\xba\x72\x4a\xd9\x41\x5a\xb4\xb1\x3b\x2b\x4f\xb3\x32\x4a\x7b\xa9\x75\xf3\x4b\x0b\xb4\xa7\xea\xf4\xc6\x95\x62\xe0\xd2\x75\x25\xd6\xdf\x2d\x1b\x31\x26\x20\x88\x94\x6a\x92\xcb\x25\x76\xcf\x84\x04\x62\x52\x39\x13\x0b\xfc\xd5\x32\xb2\xef\xd8\x12\x91\x12\xba\x01\x9d\x5c\xbb\xfb\x21\x8c\x24\x49\x9e\x8a\xc3\x58\xac\x18\x77\xb3\x6b\xe9\xcd\xf0\x67\x1c\xc9\x19\x12\x8d\xbf\x8a\xf2\x4d\xe8\xc6\xea\xfa\x2e\x22\x8f\xc6\xae\xf2\x8b\x5b\xf0\xf7\xf1\x1b\xc4\xa6\xb2\x0b\xba\xb7\x19\x7e\x3e\x33\xd4\x30\x36\x4e\xa9\x68\xb9\x64\x4e\x67\xcb\xb7\xf8\xf7\x88\x36\xe2\x08\x0a\xdd\x0d\x10\x24\x93\x16\x9b\xf7\x8a\xcf\x32\xd4\x0a\xfb\x0e\x33\xf5\x28\x19\xf1\x0a\x7f\xf6\x18\x7c\x8c\xe2\x9d\xd0\x15\x8e\xef\x70\x60\x36\x48\x5f\xae\xf7\xec\x4f\xf1\x22\x3c\x92\x84\xb5\xaa\xdc\x3e\xbd\x81\x4a\x5f\x60\xab\x16\xda\xda\x0e\xf8\x13\x39\x55\x3f\xe3\x91\x47\x1b\xa0\x7a\x50\x5d\x5a\x1b\x78\xd7\xd3\xea\x3b\x24\xed\x6c\xd9\x1a\x12\xe8\x1e\x3a\x85\x42\x5b\xf3\x45\x8c\x7f\x36\x1f\x65\x1e\x0b\x76\xc4\x28\xa7\x41\x97\xc3\x24\xf7\x9c\x95\x7f\x30\x0a\x78\xe5\x75\xbd\x03\x68\xdb\x05\x1f\x08\xb9\x31\xcd\xec\x8a\x64\xf9\xc7\x09\x9a\xf1\xfd\xa7\xc7\x92\xbf\xdb\xcd\xcc\xe0\xdf\xb5\xa7\x3f\x2e\x7e\xfc\x87\xe0\xb0\x3e\xcf\x17\xc6\x5a\x51\x11\x7f\x8d\x6c\x41\x44\x17\x1a\x37\x19\x6d\xb3\x9f\x74\x54\xf2\x34\xbe\xcf\x13\xe5\x16\x68\xa0\xda\x48\xbb\x82\xc3\x39\xb9\xa5\x3e\x50\x45\x8e\x53\x2f\x70\xd3\xe7\x70\xa4\x5d\x59\x91\x87\x57\x18\xa9\x8e\xc6\xb6\x2a\x33\xbd\xe1\xd9\xe8\x53\x93\xb1\x04\xca\xf2\x1f\xa2\x03\xc6\x1b\x04\x40\xd8\x09\xc9\x33\x24\xb8\x5f\x69\x80\x11\x10\xbc\x2c\x04\xfc\x4c\x3b\x15\xb0\x93\x23\xc4\xd0\xc0\xa9\x12\xd4\xe6\xba\x32\x46\xa2\xf7\x77\x8b\x11\xd2\x28\xbe\x25\xbd\x54\x21\x73\x58\x6c\x5e\xa1\x17\x49\xf1\xce\xb7\xff\x54\x8a\x2c\x78\x8a\x34\xa1\x4c\xd3\x41\xdf\xa8\x37\xec\x42\x11\xae\x83\xab\xdb\xb5\x9d\x83\x2a\xdc\xbd\x1a\x93\x5c\x4f\xa1\x4d\xbe\x28\x93\x4b\xd7\x78\xb3\x82\xe7\xb4\x26\x0d\x66\x4f\x38\xe5\x33\xe5\x24\xaa\x4b\x4e\x7c\x79\xc6\xb2\xb5\x0c\x62\xe7\xcb\xdf\x0b\x24\x73\xd4\xb5\xe2\xe5\xe6\xd9\x03\x2c\xc6\x13\x33\x0d\x94\x2f\x30\xef\x1d\x65\xa0\xb1\x73\x38\x59\x67\x1e\x10\x80\xd3\xd6\xb8\x7d\x92\x86\xbb\x57\xf5\x3d\x57\xbc\x7a\xc0\x4a\xc5\x6c\xa9\xea\x49\xb4\xd2\x32\x1a\xf1\xc1\x13\xdb\x71\x84\x55\xc2\x82\x2e\x49\x45\xf7\x82\x62\x3c\xb7\x73\x45\x5b\xb6\x14\x4a\xea\x53\x0e\xcb\x7a\xe5\xda\x9b\x18\x62\x86\x49\x02\xfc\x69\xc5\x9e\xe2\x6c\x4e\xfb\xd4\x5f\xc6\xbf\x02\x26\xb5\x54\xa0\xe9\xfb\x1c\xcb\x84\x82\xf3\xfb\xcf\xea\x4a\xa9\x9b\xcc\xe1\x77\x66\xab\x94\xa6\x8a\xc8\xf0\xfd\x97\x3d\xcb\x60\xd3\xaa\x5c\x73\x23\x23\x95\x3d\xe7\xd5\x32\xb0\xaa\xea\xaa\x6a\x97\x41\x2f\xf5\xc8\xd7\xef\x7a\x6a\x3b\xcc\xce\xc2\x84\xc4\x58\x2e\x97\x9a\xb2\xf4\xdd\xcc\x6a\x7d\x38\xf9\xae\x2c\xa0\xca\x23\xbb\xb2\xbf\xb3\x1d\x3d\x3f\x4d\x68\x28\x1a\x23\x2b\x3b\x1a\x97\x51\x07\x42\xe4\x1c\x27\xbd\xa9\xc6\xf8\x4f\x1a\x06\x1e\xcc\x7a\x7d\x8c\x7f\x10\x16\xfb\x05\x06\x49\xfe\x8a\x28\xae\xfb\x86\x78\x1b\x58\xa3\xd6\x46\x3c\x98\xe8\xb1\xcd\xfa\x40\x13\xa9\x68\x03\x1f\xf3\x5a\x18\x06\xb4\xf3\x66\xf6\xaa\xc7\x7a\x70\x36\xde\x47\xdc\x9d\xa7\x05\xe7\x22\x1e\xb3\xbd\x0b\x36\x45\x88\xf4\x44\xdd\xae\xa8\x78\xc6\x4d\x89\x4c\x27\xe5\x88\x7b\xcb\x2f\xd6\xf5\xb1\xcd\xa7\x9f\xc9\x62\xc3\x77\x18\xe1\x71\x31\x54\x5e\x03\x8d\x4d\x33\x47\xd8\xa9\x1a\xd2\x49\xa0\x87\x8a\x35\x93\xc7\x5c\xc4\xf3\xf8\x98\x73\x3a\xee\x0e\xa9\x42\x8b\x7a\xd8\xb7\x97\xc6\xb0\x3f\x2c\xa9\xa7\x36\x49\x39\xc9\x95\xb1\xcd\x70\xd7\x89\x00\x0f\xf8\xaa\x7b\x51\xb1\xee\x24\xaa\x2a\xb7\x64\xbb\x1e\x69\xfd\xf0\xa3\x80\xc9\xf5\x6c\x83\x2c\xf1\xb2\x22\x79\x91\x66\x07\xbf\x05\xd7\xb9\x35\x73\xf4\x4f\xd7\x81\xf5\x6f\x36\x78\x4c\x7f\xa9\x03\xe4\x71\x42\x10\xed\x5b\xfe\x6f\x5f\x30\xd8\xe8\x3f\xe7\x59\x2a\x37\x59\x5b\x28\x90\x65\x7b\xe5\x79\xc5\x4f\xe2\x88\x67\xaf\xec\x66\xc3\x27\xde\x4f\x86\x03\x68\xc6\x17\x36\x6e\x63\xa7\x90\xb1\x79\xa5\x90\xc3\xb6\x66\xdc\x0d\x5f\x56\x47\x81\xcb\xac\x79\x36\x9e\xd2\x89\x34\x19\xdd\xcd\xc6\xe6\x1f\xf4\xab\x24\x7d\x8a\x2c\xcb\x0a\x0b\xb1\x4d\x65\x39\xde\x1e\x92\x12\xd5\xc5\xe0\x8a\x67\x8c\x7a\x1f\x4d\xf9\x99\xdd\x3d\xe0\x23\x43\xd8\x1d\x11\x18\xe8\xd8\x45\xc9\x0f\xdb\xbb\xd2\x72\xeb\x00\x2f\x22\xc2\x6c\x52\x00\x28\x5f\xaa\x33\x22\x47\xfb\x98\x48\xb1\x56\x30\x3a\x39\x64\x21\x46\xa4\x0f\xad\x66\x2e\x70\xf2\xfa\x3d\x80\xdc\x91\x72\x17\x92\x69\xa7\x01\x38\x90\x14\x21\x6b\x19\x83\x96\xd8\xc7\x02\x2a\xb4\x1d\xa0\xe5\xee\xf6\x02\xbe\xa5\x0d\x3e\x8e\xed\x9b\x95\x06\x3e\x79\x95\x5a\xb6\xd5\x6a\x8e\x48\xac\xa6\x4e\x2b\x81\x72\x29\xc1\xe2\x70\xe4\xa9\xe9\x3c\x2b\x1f\xba\x69\x86\x75\x5d\x79\xd4\xf7\x90\xaf\x57\xf7\x9c\x57\x1a\x44\x29\x70\xbf\x13\xc1\x0b\xb5\x97\xb8\xec\x99\x28\xb8\xa9\xb2\xae\x30\xb4\x53\x52\x3c\xcd\x00\x95\x63\x4d\x89\xc6\xf7\xe3\x3e\x11\x01\xd9\x26\x41\x97\x3b\x93\x0a\x1b\xc1\x09\x46\x55\xe6\xf8\xec\x08\x57\x40\x74\xbb\x69\x05\x52\x3b\x39\x15\x14\x2b\x88\x53\x3d\x46\x95\x8d\x0f\x96\x33\x2f\xe3\xf5\xcf\x87\x69\x83\x0b\x09\x8d\xae\x78\xd9\x56\xe5\x9a\xd9\x19\x61\xa0\x1f\x5c\x8b\xcd\x0f\xd7\xe9\xfc\x9a\x39\xf6\xa0\x03\x51\xb4\xd4\x81\x6e\xe5\x13\x14\x7e\x3f\x01\x45\x05\x8e\xc6\x43\x0a\xe5\x4d\xda\xd4\x53\xdd\x1c\x88\xac\x55\xad\xdb\x39\x38\x52\x98\xcb\xa3\xfb\xed\xb1\x55\x79\xdc\xf1\x74\x03\x5c\xa1\x7e\x36\xff\xba\xde\x6e\x4b\x1b\xa3\x59\xd7\xe7\x90\x96\xc7\x22\x6e\xa1\x8b\xcc\x6f\x43\x8a\x23\xfc\xbd\x35\xa8\xd0\xe8\x93\xfa\x49\xbb\x3b\x2b\x20\x4d\xfc\x0e\xb4\x2f\x69\xc5\xf2\x73\xd8\xf8\xb9\x41\xc9\x1b\x1e\x44\xcf\x08\xa3\x06\xb8\xfd\xdd\x43\x52\x3a\x8c\xab\xd2\x71\x53\xa2\x69\x2c\xe5\x49\x38\x11\x03\xcc\x57\xdd\x6b\xbd\x4b\xae\x52\x9a\x2d\xa6\xe4\xca\x5e\x21\xd5\x51\x80\x7e\xa5\xe9\x6e\x9b\x52\xea\x34\x62\x58\x34\xbb\xa1\x39\x64\x73\xcf\x45\x1c\x56\x38\x83\x1d\x71\xc7\x75\xae\x39\x5f\xce\xba\xa2\xc8\xe6\xc6\x2b\x38\xbc\xc7\x8d\xd1\x04\x31\xc3\x01\xc2\x3b\x2d\x7d\x7c\xf1\xaf\xef\xfd\x6d\xdb\x25\x00\xb5\x05\x44\x8d\x49\x82\xde\xbc\xc3\x3e\x6d\x7c\xa2\x2b\xec\xc1\x05\x36\x80\x39\x08\x82\x81\x2b\x2e\xb7\x9d\xd1\x91\x8b\xc6\x5e\xd8\x19\x11\x8e\x00\x9d\x34\x07\xbd\x44\xbe\xb1\x02\xc4\xf5\x2d\x17\x69\xab\xa2\x9a\xc3\x80\xc6\x56\x69\x08\xed\x3d\xe7\xf7\xda\xc8\xcd\x2e\x2d\xaa\x0d\x94\x7c\x73\xd5\x5a\x01\xbc\x4d\xc8\xdf\xb8\xcc\x22\xcf\x02\x1d\xa1\xa6\x05\x7b\xce\x46\xd9\x64\x9e\x6c\xff\xa3\x43\xcb\x96\x6e\x7f\xb3\x82\xb1\xfc\x55\x38\xfc\xaf\x5d\x2e\x9c\x34\xeb\x77\x48\xa2\x16\x6a\x12\x9a\xb5\x7d\x58\xe3\x55\x95\xd5\xf3\xf4\x20\x3a\xcf\x99\xec\x3d\x7a\x76\xfb\xb8\x30\x1e\xc4\x74\x02\xb3\xe0\x76\x6b\xfd\xd4\x60\x6f\x58\xa8\x9f\xa5\x63\x15\x5b\x55\x69\x1f\x87\x80\x91\x1c\x95\x69\x1b\xdd\x61\xc0\x22\xd6\xcb\x49\x80\xfa\x51\xdf\x87\x96\x24\x29\x9a\x79\x4e\xa6\x2b\x55\x5e\x6c\x63\x4a\x03\x38\x5c\xfa\x7c\x66\x57\x18\x81\x1f\x06\x30\xb7\x37\x64\xd7\x4d\x64\x51\x51\x93\x19\xd1\xe0\x1a\x0f\xd7\x62\x08\x98\x24\xc9\x3a\xfa\x81\x45\xde\xe0\xe0\xe0\x16\x3f\x79\xf9\x8b\x2e\xb4\x1b\x24\x09\xa6\x2a\xab\x67\x4e\xa0\x0e\xdf\xdf\x38\xe4\x42\x86\x86\x13\x78\x8e\xa5\x6a\xf2\xba\x22\xfc\x58\xe2\x61\x85\xec\xa0\xa9\xc2\x89\x3a\x61\x8e\x55\xb1\xf5\x1c\x7a\xb0\x44\x3f\x80\x53\xd5\xa7\x4c\x34\xb8\x0d\x9b\xc0\x68\x92\xb3\x69\x39\x79\x56\xfa\xa4\x1b\xc6\x92\x75\x21\x5e\xec\x80\x0e\x18\x8c\xb5\xdc\xa4\xe3\xbf\x0b\xbe\x4b\xe9\x77\x64\x9c\x6d\x00\x8a\x8d\xd0\xd9\x89\x91\xe4\x38\x7d\x72\x46\xd3\x34\x3a\x83\x81\x8a\x58\x37\xa7\xcc\xc4\xf6\x13\x5e\x22\x71\xce\xab\xc5\x2c\xc1\xc5\x81\x55\x8e\x8a\x20\xe6\x48\xa5\xc6\x19\x3f\x3f\x4d\x8e\x64\xe6\xcf\xd5\x06\x27\x7c\xdb\xbc\x0e\xd4\xde\xd3\xed\xf0\xf6\x07\x41\x80\xcc\xb9\xfc\x09\xb2\xd5\xff\x08\x86\x23\x44\xc8\x6d\xdf\xfb\xed\x38\x32\x63\xb9\x57\xda\xcd\xbe\x2c\x4b\x07\x75\xfd\x87\xef\x1d\x73\xf4\x71\xa6\xb2\x63\x41\xd1\xa5\xaa\x09\xa3\x80\x2c\xab\xde\xdf\x32\x18\x0d\x2c\xdd\xdb\xb7\xdc\xb3\xdd\xef\x49\x40\x60\x82\xc4\x80\xc6\x79\x31\x73\xc5\xa2\x16\xa9\x6b\x86\x7f\x55\x8d\x4c\x42\x9d\x99\x64\x4f\x40\xae\x53\x14\xc0\x98\x36\x9c\x47\xc2\x97\xff\x78\x89\x33\x28\x8c\xa3\xef\xdd\x4a\x52\x2c\xc4\x47\xec\xe5\x56\x84\x27\x33\x09\x8c\xe2\x71\xe2\x2b\x7c\xcb\x13\x5a\xad\x20\x85\x01\xc1\x4c\x72\xf2\x50\xd1\xcb\xcd\xc3\x13\x6a\x6e\x7b\x2a\x6c\xfb\x1d\x90\xdf\x34\xff\x6e\x56\x02\xc8\x6f\xf1\x39\xf3\x9b\x36\xc0\xa8\xbd\x48\xbb\x67\x21\x73\x97\xbc\xab\xf0\x13\x43\xad\x00\xec\xe8\x94\x9f\x51\xa2\x6d\x86\x3d\xcd\xd4\xa4\xd4\x39\x1b\x52\x50\x71\x03\x35\xde\xc0\x0c\xce\x5e\x4d\x00\x87\x5d\x35\xc4\x5c\x3e\x4b\x6d\xc9\xca\xb3\xbe\x72\xf6\x84\xf7\x6d\xf0\x97\x36\x6c\x3c\x30\xb8\xa4\xd0\x0e\x6f\xdd\x55\x96\xe9\xcc\xa7\x31\xdf\x9e\xf9\x6a\x20\x43\x2b\x53\xdb\x7d\x0e\xb8\x4f\x1d\xfa\x71\x2a\xd3\xab\xb9\xa8\xb7\x1a\x29\x78\x56\x8b\x43\x9a\x72\x01\x18\x5f\x52\x2a\x18\xdb\xc1\xed\xaa\x57\x05\xee\xa6\x94\xab\x5c\x83\x99\x63\xdc\x5d\x3e\x08\x32\xad\x95\x16\xba\xa7\x6f\xd6\x9c\xa4\xcb\x62\x01\x23\xdd\x53\xc3\x44\x91\xac\xce\x79\xec\x44\x1c\x65\x7f\x4c\x8b\x45\x75\xde\x8c\x7d\x41\x01\x1a\xc0\x7a\x34\xad\xaf\xf7\x0b\x24\xdf\x70\x32\x7f\x98\x92\xbf\x65\x7f\xaf\xba\xd1\x3e\x7f\xc5\x75\x5f\xfc\xc0\xfb\xe0\x98\xd6\xbf\x0a\x79\x95\x26\xd2\xee\x47\x3e\xa0\xbe\x5d\xf7\x80\x8f\xce\xce\x02\x68\x0a\xf9\xe5\x27\x6c\xe5\x25\x1a\x1e\x51\x70\xc4\xa7\xc2\x0a\x84\x7a\x78\x31\x64\x6c\x81\x2d\x2f\x4e\xa0\x96\x91\xd7\xeb\xb9\x49\x09\x24\x40\x25\xc1\x3c\x2b\xca\xaf\xcf\xc7\x6c\xac\xcc\x92\x40\xd1\xca\x84\xe3\x8c\x93\x43\x97\x04\xc0\x1a\x2e\xde\x3c\x88\x88\x10\x7c\x5e\x13\xbd\x8a\xfd\x0c\xd4\xf5\x9a\x78\x42\x4a\x10\x14\x22\x48\x74\x1b\xde\x99\xc8\x02\xa6\xcd\x5d\xf1\xad\xba\x3d\xb8\xe7\x6f\x1e\x83\x4c\xb6\x4a\x30\x07\x84\x71\xb7\xa4\x6a\x76\x54\xa5\x80\x25\x8f\x68\x22\x89\x49\xba\x20\xa3\xb1\x94\x86\x31\x63\xe2\xa8\x8c\x45\x02\x87\xac\xef\xf3\xb1\xda\x9f\xfb\xa0\x14\xbb\x00\x3a\x14\xf9\x16\x94\x36\x8d\x05\x77\x5a\x13\x12\x92\xc0\x61\xdf\x57\xa2\x19\x85\xca\xda\x11\xc5\xef\x1b\xa8\x83\x43\x82\xbf\x46\xc8\xa6\xcb\xa4\xea\x63\xd8\x44\xb7\x33\x05\xc0\x5c\xa2\x3e\xbe\xda\xf0\x9d\xc9\x91\x75\x31\x07\xcf\x56\x13\x5b\x48\xfc\x1a\xd1\x0b\xab\x58\x8c\xdb\xac\xea\xc6\xce\xa9\x83\x23\x03\x57\x2e\x26\xb5\x8f\x8e\x6d\x3e\x3f\x52\x31\x74\x0f\x7c\xec\x36\x04\x85\xc6\x50\xef\x02\x19\x02\x2d\x0b\xfb\xf6\xc6\x4a\x6e\xe8\x8e\x0d\x34\xdc\x2f\x2c\xba\x83\xe5\x40\x70\xd5\x86\x2d\xe8\x9c\x96\xa9\x6d\xea\x98\x96\xee\x0e\x26\xe6\x4f\x54\xe4\xcb\x06\xde\x55\x05\x8a\x23\x07\x27\xf7\x40\x3e\xbb\x4f\x6e\xbe\x3b\x26\x39\x9e\x91\x92\xb5\xd5\x1c\xb5\x6f\x73\x9b\xab\x2e\x9a\x79\xd2\xd6\xf6\x72\x2c\x06\x59\xfc\xb7\xb0\x66\x74\xe7\x5d\x3e\x0e\x97\x52\x4b\xc7\x70\xb7\x58\xb9\xc4\x6d\xd5\xda\x61\x3d\xce\x5a\x72\x5b\x21\x2e\xd9\x22\x44\x68\x75\x6e\xd6\xaa\x09\xf9\xf5\x40\xab\xa6\x77\x80\x3c\x00\x51\xd5\x4d\xb7\x7e\xe8\x13\x36\xcd\x53\x8f\xaf\xa2\x5d\x76\xcd\xe3\xde\xee\x4b\x12\x48\x7a\xc0\x73\x6e\x52\x48\x33\xb5\xb1\x09\x88\x05\xb2\xae\xd2\x27\x14\x89\xdd\xe2\x13\x05\xe2\x92\x4d\x0f\x2d\x2c\xaf\x49\xfc\xb7\x75\xea\xc4\xda\x66\xac\xcc\x1c\xc0\x3d\x27\xec\xbc\xed\xed\x8f\x3f\x2d\xd5\xb9\x99\x32\x84\x03\xc9\x57\x4e\xbb\x62\x6c\xb6\x85\x05\xb4\x97\xca\x03\xf5\x6d\x94\x7f\x42\x1f\x96\xd9\x01\x18\x4b\x78\xcc\x50\x87\xd8\xa3\xdd\x9b\x5d\x42\x35\xcb\xdd\xac\x5d\x94\x7c\x3a\x08\x10\x9a\x0f\xe4\x39\x31\x38\x5b\x17\x35\x24\x38\x04\x9a\xa3\xfe\xe6\x4b\x0b\xa3\x7a\x30\xf7\xd6\x7c\x8a\x83\x04\x69\x3b\xa6\xbf\x8b\x5c\xb3\xf1\xc4\xaf\x9a\xff\xc3\xf9\x7c\xfc\xcd\x9c\x4a\xe5\xef\xdf\x09\x0d\xfd\x93\xba\x11\x57\x53\x32\x16\x3f\xc1\xbd\x6a\x2d\x16\xce\x3b\x3c\x28\xbe\x96\x5e\x3e\x9d\x1f\x9c\x2c\x39\xa5\xbc\xa4\xeb\x56\xc0\xc6\xb3\xa4\x0b\x36\x40\xbb\x4e\x10\x83\xc5\x6a\xb4\xf7\x69\x5b\x15\x54\xb1\xe9\x02\x75\x75\xb6\x2b\x9b\x9c\x61\x6a\x0e\x04\x47\x04\xa9\x7a\x81\x97\x24\x09\xc2\xb2\x74\xf2\x23\xe0\x85\x65\xd5\x06\x03\xff\xf1\x75\x6d\x4a\x15\xf1\x1f\x82\x07\x5d\x85\x8c\xd3\x6e\xfc\x36\x4b\x55\xc3\x2c\x58\x1e\x02\x28\xd5\x5f\x74\x22\xfd\xab\x1f\x86\x57\xfc\x0a\x52\x2f\x9a\x56\xa1\x18\xd3\x24\xd2\x43\x90\xa9\xb4\x7b\x61\xff\xa5\x57\xd7\x92\x1d\xdd\xc1\x93\x71\x36\xca\xc6\x90\x74\x9d\x21\xaa\x08\xf4\xc3\x8b\x57\x05\x3d\x8b\x55\x9e\xe4\x2a\x7b\xa2\x9b\xdb\x19\x47\xa5\xcf\x1e\x5c\xc7\xdd\x1f\x10\x8e\x2a\xc2\x5f\xe7\x82\xe4\xd4\xeb\xf7\xc8\x34\xa9\x34\x14\x05\xb9\xdb\x8a\x11\x5d\xc2\xfd\x2f\x2b\x2d\xb8\x05\x30\x47\x60\xa3\x75\xb2\xde\x9b\x01\x69\x35\xf8\x54\x14\x73\x3a\xc9\x88\x87\x3a\x50\x59\xe9\x07\xdd\x04\xcf\x30\x73\x9d\x79\x29\x48\x07\xfa\xcf\xad\x99\x62\x82\xea\x1c\xa1\x75\xae\xb3\xf6\x4c\xb0\x3e\xe4\x79\x4b\x2a\xdd\xef\xd2\xc5\x27\xc0\xf0\x32\x91\x64\x58\xb6\xf2\x0f\xad\xab\x2a\x24\x9c\x83\x29\x58\x68\x09\xff\xf0\x46\xf7\x0f\x85\x47\xf9\xb7\x8f\xab\x45\xc0\x2e\xbf\xd5\x50\xdb\x70\x09\x41\x2f\x5d\xda\x76\x18\x29\x44\x37\x58\x5a\x29\x98\x01\x82\x99\xb1\x9d\xae\xc5\x00\xfe\x11\xf6\xeb\xc3\xa5\x8f\xe8\x46\x22\xbe\x7f\xa6\x44\x21\x74\xae\xa8\x21\x25\x62\xee\x2c\x35\x5f\xf3\x82\x43\x94\x31\x14\x69\x8f\x23\x32\xb3\x91\xf1\x0b\xd3\x7b\x0f\x10\x8f\x66\xf9\x59\x89\xd6\xdb\x53\xcd\x3d\x43\x99\xc3\x41\xce\x7c\x4c\x1e\xda\x58\x2c\x86\x54\xfc\xe6\xb5\x26\x29\xe4\x52\x6e\xa9\x14\xb8\x4c\x04\x5a\xfb\x14\x05\xd3\x55\xf3\xa7\xf3\xc7\x85\x79\x6e\xc4\x10\x01\x98\x6d\x64\x6b\x6b\xfa\x07\xa4\xc3\xe8\x24\x61\x76\xcd\xf3\x6f\xa5\x56\x67\x78\xee\xf2\x66\xeb\x32\xca\x4a\x74\xdd\x02\xf3\x97\xf4\x3e\x07\x52\x9d\x22\x3a\x9a\x95\x9a\x23\xce\x9a\x2d\x85\x78\x3e\xcc\x65\x4f\x5c\x52\xe7\xe8\x70\x10\xb7\x6d\x87\x62\x02\xd1\x2d\xeb\x34\x13\x2e\xd4\xe4\x02\x42\x9d\xce\x7f\x54\x85\xef\xe9\x7f\x48\x17\xff\x21\x5d\xfc\x87\x74\xf1\xbf\x4d\xba\xd0\x39\x83\xd3\x3d\x86\xd1\xa1\x7f\x92\x2e\x7e\xff\x82\xde\xd5\xa8\x01\x19\x82\xe9\xc9\xaf\xee\xd9\x88\xfd\x35\x8c\xd1\xdb\xff\x23\xd2\xc5\xbf\xe3\x19\xff\x6d\xbc\xff\x33\xd2\xc5\x7c\xeb\x90\xfe\xe8\x3c\xff\x99\xff\x24\x53\xf4\xff\x82\xde\x71\x39\x6a\x43\xfe\x4f\xef\xe4\xc7\xe0\x12\xce\xe4\x79\xc4\x61\xff\x27\xa4\x8b\x7f\xc7\xb3\xff\xfb\x78\xff\x97\x20\x7a\x04\x12\xf9\x39\x4d\xd3\x4a\xfe\x5f\xa4\x0b\x41\x29\xbc\xc7\x60\x04\x0e\xce\xde\x3e\x07\x8f\xe3\x2a\x8e\xe3\x08\xc5\x5a\x86\xb2\x78\xf3\x6b\x2e\x99\x8d\x78\x75\x14\x08\xc6\x7a\xdd\x89\xa4\xeb\x66\xc0\xc6\xf6\x24\xf0\x16\x1a\xdd\xe1\x95\x4a\x60\xec\x87\xe9\x1a\xdd\x91\x05\xde\x76\x59\x7a\xb0\x1f\x35\x16\xeb\xba\xf5\xd1\x12\x95\xb2\xa9\x8a\x90\x4c\x38\x60\xde\xa7\x7a\x6a\xa4\xc6\x6c\xf8\x7e\x0b\xf6\x0d\x9f\x60\xf0\x4f\x3c\x2e\x67\x09\x76\xa3\xe7\x26\xf7\xcf\x4a\xe8\x01\xd6\xe9\x9b\xf3\xa0\x9c\x30\x09\xe4\xbe\xac\xe2\x2c\x4a\x23\xed\x2d\xe3\x30\x13\xe8\xd8\x75\x22\xbf\xbe\xc2\xcc\x7f\xaf\xf1\xd3\x38\x7a\xf7\x04\x87\x56\xfa\x1d\xec\x59\xc4\x7a\x04\x27\x28\x51\xca\x6d\xf1\x0a\xcb\xde\xf2\xc3\x11\x7e\xa1\x79\x09\xac\x0d\x03\x26\x85\x1f\xea\xb4\xa0\x99\x3f\x15\x61\x1e\x85\xa6\x2f\xaa\x87\x21\x3b\x98\x58\x35\x9c\xcb\xae\xb2\x80\x16\x74\xd4\x90\xc7\x7c\x1a\x3b\xab\x24\x47\x94\x52\x83\x39\xbd\xa6\x29\x58\xce\x7e\x30\x42\x77\x7a\x74\xd7\xe5\x47\xbe\xcd\x7a\x04\x33\x6a\x64\xab\xa3\x0e\xf9\x93\xbb\x1a\x8c\xd7\xc9\xad\x20\xce\x4b\xaa\x41\x4e\xf6\x89\x09\x49\x85\xa7\x0e\xbe\x33\x01\xa4\x88\x5b\x1c\xe2\x26\x8d\xa6\xdb\x1d\x85\x87\x74\xab\xd3\x0d\xe2\x44\x42\xac\xca\x04\x39\xe4\x4a\xfe\x50\x61\xcc\xb0\x6f\x2e\xb3\xd3\x62\x64\x73\xe7\x87\x0b\xf7\x8b\x21\x16\x4b\x1a\x84\x83\x6e\xbc\x09\x73\x02\x3a\xed\x84\x05\xe4\xb0\xb2\x93\x2d\x12\x20\x79\x97\xae\x18\x18\x4b\xa6\x80\xc8\x26\xa5\x9b\x39\xd0\x75\x5b\x50\xd4\x50\x20\x2c\x23\xd1\x81\x7e\x68\x9c\x77\xae\xc5\x26\x5b\x1f\x53\x8e\x68\xdd\x3c\xf8\x5b\xa4\x57\x6e\x0d\xf2\x3a\x0b\xfa\x9e\x07\x7e\xfe\xce\xd3\x61\x7a\x55\x50\xfa\x21\x07\x94\xac\x97\x8a\xac\x69\xd6\xe0\xb2\x8f\x76\x73\xfb\x71\xb7\x57\xdf\x65\x07\x6b\x45\x50\x29\x51\x5f\x64\x2a\x39\x1e\x88\xdd\xa7\xaf\x49\x51\x34\x04\x42\xc7\x66\x63\xb8\x0c\x0f\x41\x1e\x01\xbe\xc3\x37\xd3\x6e\xa1\xd8\xab\x2d\x30\xcd\xc1\x4f\x9b\x31\xfa\x39\x1d\xcb\xe7\x93\xa3\xf2\xb6\xa8\x97\xc3\x26\x06\x0c\x94\x0f\xe1\x13\xf1\x90\x36\x48\x5a\xd2\x07\x73\xdb\x46\x6b\x07\x79\x0c\x1b\xc4\x6e\x7d\xa6\xe8\x92\x37\x2f\x94\xdb\xff\x76\x2d\x85\x6b\x52\x03\x68\x47\x29\x26\xb7\x51\xd9\x21\x46\x8f\x73\x32\x70\xea\xf8\xb5\xa2\x16\x7b\x03\x7b\xa4\x7d\x27\xc4\x44\xfd\x18\x34\x53\x18\x28\x83\x12\x4c\xba\xae\x73\xec\x91\xcb\x1b\x41\xed\x84\x99\x4e\xe6\xf4\x32\x8d\xe1\xf1\xc0\x39\x99\xef\x65\x4c\x82\x28\x19\x68\xdd\xd8\xda\xaa\xc2\x94\x2e\xf9\x62\xcd\xd4\x52\x64\x5b\x4d\x72\x1d\x6d\x32\xbb\x50\xf3\x9a\x32\xee\xe2\x4e\x94\x61\xdf\xe7\xbf\xec\x04\x1f\xa6\xa6\xa5\x3e\x64\x71\xdf\xa2\x39\xcf\xfc\xb3\x6a\x22\xff\x8f\x9a\xf8\x8f\x9a\xf8\x8f\x9a\xf8\xdf\xe7\x66\xf5\x3a\x66\x77\xf1\x6b\x70\xc1\x5f\x11\xba\x8c\xc3\x27\xac\xc1\x19\xbc\x0e\xf1\xff\xe8\xac\x90\xee\xcb\xff\x33\x6e\xd6\x7f\xc5\x4b\xfe\xdb\x78\xff\xa7\xdc\x2c\xfb\x6b\x58\xa3\x93\x21\x1d\xfa\x2b\x42\x57\xe0\x9d\xfe\x1f\x9f\xd9\x9f\xed\xf1\x8f\xe9\xd9\x8f\xdd\xfe\xcf\xb8\x59\xff\x6f\x3c\x83\xff\x6f\xe3\xfd\xdf\x51\x13\x7d\x05\xbf\xa5\xfe\x0f\x35\x91\xfd\x5b\x4d\x18\xff\x4b\x4d\x40\x87\xe6\x6b\x0b\x43\xc1\xe7\x5c\x04\xa1\x35\xce\x9b\x2f\x3f\x33\x14\xb8\xad\xe1\xf2\x8f\x1e\xc7\x12\x8f\xa2\x03\xe4\x17\x60\x3b\x01\x2c\x60\xba\x5d\x5c\x77\x8e\xc8\x31\x0e\xab\x2a\xb2\xdf\xcb\x7c\xd8\x42\xa1\x3a\x74\x29\x74\x0e\x08\x02\xfc\x10\x98\x1a\x14\x04\xaf\xb5\xb2\x2d\xbf\x33\xba\x26\x62\x9b\xa6\x69\x1b\x36\x5f\xf0\x83\x71\x47\xf5\xab\x40\xb2\x4e\x7e\xcb\xcf\x09\x34\x86\x86\x3e\x91\xfe\x66\xbc\x6b\xba\x11\x3e\x4a\x80\xe0\x7d\x94\xd8\x04\x13\xb8\x09\x65\xd0\xb3\x43\x04\x4a\x4b\xf9\x8d\x66\x9a\x8c\x79\x0b\x4e\xbb\x35\xe0\xa6\xc1\x1c\x37\x4c\x86\x9c\x9d\x53\x47\xb2\x42\xfb\x42\xc4\x9d\xd7\xee\x51\x00\x1a\x82\xea\x2c\xce\xf5\x49\x8b\x34\x17\xdc\xba\x0b\x10\x5a\x74\xdf\x79\x71\x35\x7e\x49\x4a\x28\xd0\xcb\x26\x80\xf4\xf6\x94\xe0\xdc\x4e\x3b\x0e\xc4\xdb\x3b\xaf\x6c\xeb\x33\x97\x61\x9a\x00\x21\x6c\x91\xde\x4d\x61\x0e\x85\xaf\x4c\x9b\xb6\x05\x19\x98\x31\x91\xf2\xba\xba\x9f\xf5\x20\xfb\x3d\x0c\x7b\xbc\x26\x03\x42\xd6\x2a\xc9\x71\xaf\x73\xe5\x8f\x1a\xd9\x17\x83\xd7\xb2\x1b\x2f\xed\x5d\x4b\x40\xc7\x07\x2d\x11\xd3\x55\x88\x4d\xfc\xda\x43\x96\x72\x73\x73\x65\x94\x1d\x1d\x11\x56\x5a\x22\xbb\xd5\x34\x92\x3d\x0b\x38\xea\xff\xc4\xb4\x45\x98\x09\x2e\x97\xd9\x0a\xc7\x31\x55\xe7\xb3\x86\x7d\x66\xd6\xb7\xfa\x96\xd2\x4c\x0e\x02\xf6\x41\xba\x62\x53\x85\x7b\xc4\x09\x2f\x41\x96\x61\x28\x2c\x5b\xac\x91\x5c\xfd\x49\x4d\x29\xfb\x7a\x96\x26\xab\x1a\x50\xf2\x84\xd7\x2d\xc7\xbe\xa8\x6e\xc4\x11\xcf\xd6\xaa\x8c\xd4\x32\xfb\xcc\x36\xcd\xef\xb6\x7c\x2c\x06\x2b\x85\xea\x54\xeb\x33\x04\xa7\x9b\x17\x83\x9d\x20\x7f\xd9\x79\xb8\x8d\x72\x46\x0d\x2c\x8c\x94\x20\x8f\x71\xab\x13\x87\x77\xa8\xe6\x91\x99\xc0\x31\x1b\x94\x91\x03\x95\xfd\x73\x45\xdf\x94\x83\x78\x20\xa4\xcf\x92\x25\x24\x76\x12\xe8\x45\xd4\x04\xd8\x83\x8f\x91\x26\xe4\x82\xc7\x45\x17\x1f\x88\xf3\x52\x07\x9d\xbe\xea\xae\x44\x5e\x29\xde\x4c\xec\x8b\x19\xbc\xf9\xb6\xe6\xde\xeb\xd1\xbe\x1a\x7b\x5b\xde\xbd\xe6\x2e\x69\xaa\x02\xa3\x4c\xba\xd4\x14\xa4\x28\xeb\xd4\xd5\x64\xcb\x34\xf1\xeb\xae\xdb\x38\x4d\x1d\x7e\xf3\x1c\x87\xe7\x8b\x89\xd4\x4b\x25\x73\x83\xe4\xa7\x13\x93\x56\x18\xfc\xb3\x0a\x5a\x6a\xdf\x7c\x25\x54\x34\x6b\x4f\x30\x20\x31\xa1\xea\xaa\x19\xaa\x7b\x98\x5b\xef\xc7\xd9\x50\x57\xc0\xa5\x40\x66\x63\x9c\xe9\xf0\xf8\x8c\x3b\xc3\xbe\x7c\x7a\x4f\x79\xa6\x55\x6d\x40\xd5\x6a\x0a\xab\x09\xf1\x86\x7a\x89\xab\x1a\xb9\x4c\x00\xa9\x72\x87\xf6\x68\xe9\x80\xd7\xaf\x4e\x8d\x51\xc7\x89\xff\x2a\x50\xc9\x69\x5a\xbf\xf5\x74\xc7\x43\x5f\x2d\xfe\xf0\x86\xd2\xbe\x0e\x7f\x2f\x31\xd1\xfc\xd7\xc1\x36\xb2\xcf\x8f\x7f\x2e\xe9\x3f\x1b\x90\xbc\x91\xde\xcf\x29\x6c\x30\x8e\x99\xba\xfd\xe2\x31\x3c\x82\x5a\x4d\x82\xfc\xf2\x75\x40\xde\x5f\x71\x5e\xb4\xe5\x17\xa2\xe0\xc2\xc2\x23\x3b\x0e\x13\x25\x83\x60\x53\x62\x50\x70\xbc\x21\x37\xa2\xf2\xf4\xdc\x7e\x23\xe3\x54\x26\x93\x4e\xa2\xdb\x69\x24\x83\x39\x1a\x33\xd7\x7c\xc3\xf7\xa1\x05\x48\x7d\x17\xea\xce\xf7\x43\xb2\x0d\xb8\x0e\xb1\x8a\x44\x3a\x9a\xf3\xca\x9e\x49\x10\xb0\x76\x01\xb8\x15\x38\x78\xe2\xa9\x01\x93\x19\xe1\xe8\x82\x07\x50\xe9\xbc\x5b\x20\xff\x00\x50\x5a\x82\xcb\x79\x13\x1d\x8a\x5b\x83\xca\xeb\xf4\x97\x1f\xaa\x82\xa6\xa2\x90\x8e\xba\xd4\x05\x50\x01\xdc\xb9\xd8\x1e\xbd\xbe\x2d\x61\xb8\xe0\x4d\x20\xe7\x2d\xdf\x23\x3a\x6d\xde\x99\x1f\x76\xf3\xfe\x40\x7e\x2b\xcc\xe1\xaa\x2c\xa2\xfe\xfc\x38\xe3\x33\xb9\xf5\x97\xca\xd6\x9c\x92\x08\x1d\x32\x35\x38\xbc\xaa\xa6\x4b\xb0\xa5\x2f\x60\x4a\x45\x97\x16\x69\x9f\x08\xe7\xa7\x30\x30\x69\xb8\xb4\xea\x93\xca\x96\xab\xc5\x38\x9b\xb2\x14\x5a\xd7\x76\xf7\xb6\x76\xe2\xf4\xa5\xed\x7e\x9a\x33\x5f\x62\x6a\xe5\x6d\xa8\x1d\xbf\x2a\x75\x43\x9e\x99\x1b\x5c\x65\x2e\xb3\x69\x53\xa3\x4e\x21\x20\xa6\x96\x3b\x15\x9e\xeb\x24\xb6\x6a\x21\x85\xdf\x12\x72\x07\xb0\x1a\xfa\x82\xc8\x6d\x27\x89\x77\x51\x84\xec\x65\x00\x28\x0a\xb2\x33\x6d\x5a\xbf\x29\x28\x3c\xca\x2d\x66\x1b\x56\xfa\xba\x6e\x6d\x3c\xbe\x36\x22\xc0\x21\x80\xfa\x88\xb4\xa7\x91\xba\x92\xa8\xdc\x11\xc8\xc6\xfc\x09\xbf\xa0\xc4\x06\x9b\x16\xa8\xf3\x54\x81\x55\xd8\xdf\xa1\xff\x76\xfb\xd9\xf2\xd4\x1e\x21\xac\x29\xc2\xde\x21\x51\xfd\xab\x16\x6a\xb3\xd1\x8a\x16\xbe\x93\xb2\x1a\x1c\x08\xf5\xaa\x1b\x70\x70\x11\x99\x22\x43\xba\x4c\x1d\x1f\xd2\x1e\x9c\x2e\x7c\x7f\x57\xff\x36\x7e\xc2\x58\xb5\x59\x8a\x86\x64\x50\x74\xc6\x69\xa2\xff\xe1\x52\x89\x34\x41\x87\x6a\x03\xc5\x92\x60\x79\xed\x45\x9d\xea\x2a\x24\x05\x64\x96\x8f\x9c\xe7\x43\xbe\xcf\xc4\x51\x5e\x16\x0e\x60\x68\xe2\x24\x41\x32\xda\x5d\x5c\x0f\x3b\xfb\x8b\xe1\x82\x85\xb1\x20\xcc\x1c\x5b\x31\x1d\xac\x28\x19\xad\x49\x7f\x61\x52\xf3\xaa\xfd\xb3\x8f\xdf\x20\xaf\xda\xdc\x65\x69\xe4\xda\x5e\xee\xbc\x88\x79\x7b\x98\x9b\xac\x3d\x24\xc7\xb4\x59\xf7\x41\xe8\xf3\xc0\xf0\x44\xe0\x97\x41\xdc\x22\x18\x4b\xef\x7d\x63\x32\x56\xc2\xf1\x95\x77\x23\xc5\x79\x75\xfb\x31\xad\x27\x63\x90\x26\xf6\xa0\x09\xd2\x1f\x1d\x05\x8e\x3a\xfd\x7b\x25\xef\xff\xcf\x51\x78\xe4\xa7\x22\x88\xac\x39\x62\xbb\x64\x08\xb2\xe8\x22\xae\xe4\x2e\x6f\x7b\x99\x2f\xdf\xd3\xfc\x3d\x0b\x93\x5f\xe5\x52\xf2\x16\xa4\x5a\x73\x9d\x7b\xe0\x3d\x18\x1e\x4c\xf4\xb2\x9a\xf1\x23\xdb\x08\x7e\xac\x8a\xc1\xa1\x41\x0e\x52\x6b\x87\xc1\x0e\x68\x02\x27\x28\xf0\xb9\xf4\x30\x4f\x63\xf9\x99\x25\x68\x02\x14\x81\x5e\x57\xc2\xef\x2f\xa6\xc4\xd3\x5a\x58\xfa\x89\x3b\xbd\x6b\xc7\x36\x42\x29\x7c\xcf\x00\x56\x92\x6f\xfb\xb0\x1d\x56\x63\x0f\x08\x1a\x24\x39\x09\x1e\x1b\x25\xc3\xaf\x2e\xd5\x10\x4f\x93\xd2\xc6\xe8\x10\x36\x04\x02\xdd\xcc\x31\x4a\x56\xae\xcb\xd9\x81\x81\x2e\x95\x1a\x90\x22\xa1\xe6\x4f\x22\x0d\xf8\x05\x3f\xd9\xb0\xfa\x68\xa9\xe5\xe8\x82\x04\x42\xd2\x6d\x38\x50\xdb\xf5\xbd\x4f\xcd\x27\x7a\xe7\x8a\x1b\xcd\x8e\xf7\x71\xb2\x46\xdd\xad\x41\xa2\xd0\xf0\x03\xea\xe3\x90\x59\x4d\x77\xb8\xc3\xa2\x78\x6c\xbe\x6a\x38\xbb\xda\x2f\xa5\x2c\x33\x8b\x2a\x3b\x87\x0c\x2b\x44\x1e\x11\x4d\xe4\x34\x39\xa8\x9b\x4d\x74\xff\xb8\x9e\x4d\x44\x11\xf9\x22\x3a\xed\x3e\x41\x9e\x19\xfd\x9a\x6a\xf8\x5d\x64\xd5\x5c\x47\x0b\x85\xc4\x10\x35\x65\x3e\x6f\xc7\xf9\xfa\x86\xc7\x79\x7f\x4e\x4d\x0b\x37\xc7\xd3\xb2\xc9\xf5\x6c\x3e\xca\x7a\xd1\xda\xda\x6e\x14\xe1\xad\x27\x85\x32\xd4\xe4\xf2\xf1\xfe\x01\xa7\x4c\xa3\xae\x68\xd4\x4e\x8f\x1a\xaf\x02\xf5\xda\xd9\xea\xc8\xeb\xae\xbf\x00\x24\xbe\x2f\x46\x64\x6a\xed\x87\x91\xab\x1d\x1c\x6f\xf0\xbf\xbb\x38\xce\xd5\xa6\xbd\xf1\x07\x09\x70\x30\x59\x99\x23\x96\xfc\x4d\x4a\x51\x92\xb5\x01\x59\xed\xdc\x25\x53\x43\xd1\x9d\xd4\x45\x73\xf4\xdb\x36\x1a\x9f\x6d\x21\x9d\x34\xe6\x1c\x2c\xe8\x87\xb7\x2b\xe3\xb7\x0c\x4c\x63\x13\x5f\xdd\x2c\xbf\x67\xbd\x06\xea\x98\x57\xf3\xbf\xe9\xd7\x71\x0f\x30\x7b\xfc\xb7\xc0\x05\x39\x52\x07\x4b\x4a\xb8\x9e\xd2\x0c\xd4\x8e\xdf\x03\x19\x3e\x18\xaa\x7e\xcc\x03\xc3\xcc\xbf\xe9\xcd\x31\x33\x72\xb6\xb8\x27\x56\x1e\x4e\x1b\xf4\xb3\x5d\x0f\x49\xd4\x31\x2b\xb2\x4f\xc4\xab\x81\x72\xb1\xa1\xb0\x8b\x68\xd9\xc0\x97\x01\x2a\x98\xc9\xe1\x66\x81\xf9\x2c\x39\x43\x22\xea\x45\x84\x27\x6a\xd2\x2d\x53\x2d\x6f\x8f\x97\x40\x45\xb8\xd0\x10\x02\x06\xb6\xf1\x0b\x88\xb9\x66\xea\xee\x50\xf1\xb5\xb8\x5b\xd0\x5a\x18\xe6\x18\x41\x4c\x2b\xaa\x4b\xd0\x07\x70\x76\x83\xf0\x14\x22\x19\x58\xb3\x4b\x05\x5b\x5e\x2e\x03\x31\x51\xd6\xf8\xb2\x03\x22\x96\x89\x98\xe5\x50\x94\xdb\xd1\xc1\x4c\x49\x3c\xb6\x02\x95\x6a\xf0\xd0\x35\xfc\xd2\xfb\x74\xe7\xa6\x2b\xdb\x2e\x73\xca\x2a\xe8\xe8\xc3\xaf\x79\xdb\x51\x89\xb8\x69\x29\x53\x9d\x88\x49\x0d\x93\xe7\x19\x5c\x2b\x1c\x50\xfb\xae\xa7\x54\xde\x42\xd2\xd6\x1b\xee\x87\x21\x97\x9f\x3d\x60\x88\x51\x23\xb1\xaf\xd8\x85\xc9\x3a\xcd\x98\x6b\x8b\xf2\x1d\x91\xd1\xff\xfa\x43\xf0\x0f\x7a\x09\x8f\xfa\xfb\x9b\x15\x8f\xbf\x6e\x31\xfd\x73\x37\x39\xb6\x32\xfd\x73\xbd\xaa\x38\xe4\x49\x38\xfa\x7e\x69\xd3\x28\x08\xe7\x13\x11\x1c\x9f\x9f\xc0\x7d\xc6\x95\xb3\xd6\xc0\x59\x02\xe9\x0a\x60\x60\x8a\x24\xdb\x0a\x83\xba\x5c\xe0\x1d\xdb\x77\x0c\xc6\xb5\x0b\x2e\x1c\x34\xdb\x40\x86\xfd\x2c\xc9\xa9\x4c\xf6\xe4\xca\x09\x61\x36\x37\x6e\xff\x74\xe2\xf7\x4d\x95\x39\x06\xe3\x78\xf8\xf1\x7b\x6d\x2f\x00\xa0\xf8\x5b\x99\xa5\x0b\xaf\xeb\xc7\x1d\x97\x84\x58\x04\x4e\x2f\xd6\x10\xa2\xdc\x96\x21\xbb\x54\x3e\xe0\x99\xe7\x52\x48\x17\x59\x12\xa1\x50\x6f\x22\x00\x83\xee\xad\x81\x7e\x8d\x37\x49\xa7\x8d\xe3\x00\xf5\x6b\x31\x04\xed\x3e\xe1\x33\x83\xa1\x63\x0a\xd5\x4c\x0c\x29\xfd\xae\xc0\x23\xca\xdf\x2d\x00\x6e\xc2\x74\x54\x9b\x28\x00\xaa\xc0\xf0\x98\x85\x48\xef\x90\x1e\xa6\xdd\xc2\xd0\xfe\x5a\xac\x5a\x3d\xff\x9a\xf2\xcf\xf3\x17\xca\xd1\x0e\xae\x51\x6b\xe5\x81\x56\xac\xe0\xef\x90\x7e\x36\x87\x57\x65\x56\xe2\xf7\x39\x8e\x23\x3d\xba\x86\x3c\x1c\xd7\x53\xab\xc7\x98\x80\x5f\xb6\x17\xc1\x1c\xa2\x7b\xda\xa9\x35\x3d\x59\x26\x9d\xd3\x17\xd1\xf8\xf8\xb8\x84\x0a\x71\xc1\xa5\xfb\x1a\xa5\x25\x93\x58\x38\xac\x28\x7d\x12\xd8\x5e\xb2\xcd\x37\xe6\xad\xcf\x55\x6e\x1b\x61\xf0\x9f\x37\xfe\x8c\x44\x44\x85\xbd\x69\x47\xfc\xce\x74\x43\x99\xb0\x6c\x91\xe6\x5b\x57\x0f\x79\x9d\x11\xd6\xac\x1d\x44\xce\xe9\xe5\xb8\xbb\x2b\xaf\x67\xbc\x25\x88\xb6\xee\xf8\x31\xe0\xd6\x2c\x26\x1f\x5b\x81\x83\xdb\xf1\xb5\xa6\x65\x64\x1c\x10\xa9\xa4\x42\xf3\xcc\xfb\xda\xf3\x93\xb9\x7e\x94\x5c\x63\xe5\x59\x4f\xa8\x6d\x37\xe7\xf3\xf8\xcc\x11\x83\x26\xbd\xbc\x88\xef\x88\x03\xc4\x5e\x05\xbd\x38\x30\x80\x93\x40\xc2\x4d\x3e\x8b\x96\xe6\xc8\x19\x9f\x69\x07\x71\x1c\x76\xb4\xf5\xae\xdd\x51\x56\x7e\xe1\xd6\x5d\xac\xd7\x65\xa3\x46\xf0\xa2\xf2\xa5\xeb\x06\x63\x1c\x40\x09\x6e\x72\x49\x4f\xad\x85\xd8\x05\x7b\xd9\x88\xa2\x29\x48\xb0\x9b\xc9\x65\xe2\x63\x12\xc0\x1e\xb0\x01\x29\x4e\x47\xaa\x3d\x2a\x39\x61\x50\xfb\xf2\xc8\xaf\x23\x23\x37\xfc\xf1\x8d\xe1\xed\x54\x7b\x65\xae\x76\x5b\xfe\x67\x69\x86\xa5\x30\xb2\xce\xab\x53\x6a\xc7\x35\x9e\x32\x14\xe0\x88\xce\x3f\x84\xcc\x6e\xd4\x93\xa1\x46\xba\x0c\x1b\x85\x22\x8a\xbf\xb0\x92\x3e\x21\xd0\x14\xa2\x27\x73\xf2\xf1\xa7\x7a\x09\xe6\x62\xe0\x5c\x31\x13\xe2\x8e\x8c\xb1\x57\x5f\x4c\x11\xa2\x06\xa9\x42\x5f\x59\xb0\x3e\x1a\xad\x6e\x29\xf1\x68\x3b\x38\x7c\x4c\xf1\xbd\x52\xe0\xb6\xa2\xe6\x8a\x41\x26\x6f\xfa\xfb\xd9\x2f\xa2\x3e\xfb\xed\x94\x32\x61\x9b\x5c\x92\x9b\x1b\x94\x48\xe8\x8a\x34\x32\xc7\xc8\xc4\xb7\xc2\xf8\x71\xf6\xa8\x60\x58\x0f\x2d\x63\xb7\x01\x2c\xfd\x9c\xe7\xf1\xcc\x63\xb1\xe2\xff\xf8\xc2\x3f\x74\xcc\xde\x0f\x04\xbf\x10\xdc\xba\x65\x9d\x56\x3b\xd4\x02\x91\xd8\x57\xeb\xf8\xcf\x2a\x8e\xb6\xfa\x9b\x19\x09\x46\xe7\xaf\x07\x9e\xff\xe5\x28\x5c\xe3\x4f\x0a\xf7\x63\xd8\x62\xc5\xc8\x43\x9f\x1f\x5e\x5f\xd9\x53\x43\x6c\x28\x06\xaa\x61\x6d\x86\x2e\x8a\x7f\x09\x92\xcf\xb6\xe0\x61\x9a\xe8\x94\xdc\x66\x44\x7e\xb1\xc8\x28\x8e\xbd\xd0\x31\xc3\xf1\xe1\x92\xf2\x16\xdf\xf4\x7b\x11\x2c\xd9\xdb\x7d\x57\x69\x62\x7a\x95\x70\xac\x17\x66\xe9\x59\x56\x39\x81\xe2\x96\xfc\xb5\x26\x4d\x10\xa6\x25\x21\xaf\xc2\xe6\xae\x58\xd4\xc8\xd9\xef\x36\xad\xce\x95\x30\x9f\x20\x11\x6c\x07\xed\x3a\xcb\x15\x18\xef\xd4\xc1\x68\x85\x47\x66\xd3\xd5\xa4\x44\x0f\xba\x27\xdb\xc5\x0b\x6a\x26\x70\xa1\x67\xec\x5b\x5e\x4f\x4b\xac\x97\x01\xb9\x0a\x40\x4b\xf1\x8a\x2a\x0e\x34\xd9\x75\x62\xe0\xd3\xbe\x52\x36\xe5\x31\x7d\x57\x0e\x4c\x25\x75\x26\x82\xdc\x6c\x52\xda\xee\xd6\xa5\x57\x50\x4a\x34\x3f\xd5\xab\x8b\xc8\x76\xd9\x5c\xc1\x0c\xb7\x9c\xa4\xa7\xfd\x3b\xab\x06\x46\x8e\xbb\x9d\x7d\x8c\x07\xa6\xd8\x87\x0d\xd9\x61\x0d\x99\xdb\x01\xe6\x40\xc8\x31\xfa\x1e\x32\x30\xce\x84\xa0\xf0\x8e\x5a\x41\xae\xa6\xef\x79\xbc\x57\x76\x68\x07\x7a\x14\x20\x81\xc7\x6e\x56\x9e\xe8\xa1\xef\x4c\xec\x05\x36\x48\xa9\x8d\x08\x99\x77\x3c\xb2\x62\x17\x59\xc1\xdc\x7e\xe9\xdc\x4e\x0f\xa1\xa3\x21\xc6\x92\x70\x23\x6e\x97\x3c\xa7\x6f\x59\xf4\x5f\x84\x0d\x14\x21\x91\xa7\x5e\x1d\x5e\x85\x5e\x1f\xd4\xc3\x40\x59\x17\x47\xa5\x2f\x43\x39\x74\xbf\x9f\x5a\xcb\xbf\xa5\x68\x32\xf4\xe5\x22\xf7\xc7\xb9\x6c\xdc\x90\x9b\x27\x73\xe4\x0e\xdd\xe5\x53\x06\x1c\x24\x1e\x7a\x41\xfe\xd4\xbe\x2f\x2b\xe1\xf1\x2b\x1e\x23\x74\xd8\x98\xfb\x4c\xe9\x99\x97\xb7\x07\xfc\xd0\x80\xf9\xa4\x65\x40\xf7\xef\x4c\x68\xa6\x38\x4b\x15\x35\x07\xdd\xb5\x86\x1e\x4c\xc2\x4a\xce\x11\x39\xfa\x87\x57\xbe\x49\x33\x34\x05\x8a\x3b\xbb\xa4\xb2\x74\x6f\xa4\x60\x36\x36\x89\xa0\xe6\xcf\xa9\x42\x1c\x3f\x7c\x91\xe6\x1a\xe3\x45\x1d\xc3\xe1\xba\xdc\xc0\x60\x49\x7b\x0a\x9b\x54\xf0\x2e\xf6\x76\xd3\xd6\x2a\x53\x61\x54\xac\x02\x76\x04\x3c\xe7\xf4\x68\x66\x43\x54\x3d\x58\x3f\x84\x32\x90\x92\xa7\x08\x3d\x3e\xa9\xf8\x15\xbc\x75\x75\x40\x37\x56\x31\xe5\xcf\x0b\x70\x9a\xdb\x11\xe7\x77\x0e\x31\xc7\x19\x7d\xdc\x2d\x10\xd7\x6c\x02\xf0\xb1\x41\xdd\xdf\x28\x0c\x5c\xb0\xff\x74\x76\xd2\x1b\x01\xe4\xd2\x5c\x81\xcc\xb0\x2e\x9f\x39\x55\x8f\x31\x00\xf6\xda\x93\x41\xa0\x2f\xcc\x52\x69\x15\x14\x0d\xaf\x5f\xe9\xcf\xea\xd2\x0e\x0f\xf5\xe4\x5a\xf8\xd5\x35\x70\x82\x5f\x19\x54\xa7\xbd\xf6\x3a\x95\xb1\x06\xfc\xee\x5b\xa8\x46\x4f\x71\x58\xf5\xe5\xe6\xb7\x4f\x8f\x3f\x32\x4a\x7e\x48\x08\xe3\xf6\x6b\x1d\x6d\xe5\xf8\x5f\xfb\x23\x49\x31\xe3\x5b\xf8\x3b\x24\x6b\xbf\x6e\x9a\xc5\x4e\x96\x5a\x9b\x69\x4f\xae\x3f\xbd\x9e\x70\x3c\x7f\xb3\xfd\x84\x52\xf9\xaf\xc7\x04\x7f\x3b\x4c\x11\xe6\x6d\xab\xda\xdf\xa8\x7d\x3f\xa6\x3e\x65\xc5\x7d\xd9\x26\x61\x18\x5e\x60\xd5\x45\x95\xb4\x19\x2f\xeb\x85\xdf\x8c\x89\x64\xa5\x5a\x22\xeb\x3e\x91\x5b\xcf\x95\x23\xad\x51\xe8\x90\xad\xfb\x59\xaf\x1d\xdd\x6d\x1d\xc6\x55\x11\xea\xc3\x5e\x0a\x90\xe1\x02\x94\xd8\x4d\xc8\x50\xdd\xb3\xa6\xa9\xeb\xbf\x61\xb1\xdd\x77\x8a\x81\xca\x22\xa0\x4a\x14\x90\xda\x3e\x99\x97\xfd\xf0\xa1\x2a\x0a\xca\x3f\xb7\xea\xda\xb6\xae\xdc\x71\x02\x47\xca\x0c\x3d\x3e\x1b\xa7\x4e\x41\xb9\xad\x7d\x35\x2d\x16\xd0\x19\x7e\x7c\x9e\xa5\x69\xb1\x63\xf0\x7f\xa6\x38\xee\xe6\x97\x32\xa1\x96\x03\x26\x35\xcb\x72\xd0\xb8\x79\x5b\xf4\xaf\x98\x90\x97\x84\x23\x93\x74\xb8\xea\x90\xca\x58\xbe\x97\xb8\xd7\xd1\x95\x9b\x0a\x0c\x93\xe7\x33\xc4\x87\xeb\x7b\x7d\x67\x36\x2e\xaf\xbd\x75\xa0\x10\xf5\xc4\x2f\xb7\x53\x97\xd7\x4b\x3d\xf2\xc9\xe7\xed\x2d\x1a\x94\xba\x02\xc4\x41\xcd\xc9\xdf\x8e\x5f\x0e\xa4\x25\x24\xba\xc4\x68\xc4\x2b\xb5\x24\x54\x7d\x53\x49\x03\xed\xe9\x10\xa2\x23\x61\x94\x97\x44\x95\x8d\x52\x5a\xe1\x9f\x13\xc4\x18\xb3\x68\x69\x9e\x83\xc8\xad\xb5\x39\x64\x6b\xcd\xad\x7c\x5e\x67\x8e\x73\x94\xbd\x76\x3a\xd3\x44\x9a\xee\x92\x3a\x25\xae\x3a\x11\x11\x34\xd4\xd9\x82\xb9\xe6\x47\x55\x72\x14\xf7\x1c\x66\xd0\xdb\x34\x45\x14\xe6\xed\x8c\x75\xe5\xc8\xb5\x8f\x73\x78\xe9\x38\x95\x48\xb3\xf2\x05\xc0\xb8\xd9\xc2\xa1\x52\xf7\xbb\x59\x5a\xd6\xa1\xf0\x94\xf7\xa9\xf9\x07\xd8\x3c\x5a\x23\xf3\x15\x84\xdc\x88\xb8\x39\x82\x64\x8c\x3d\x92\xd7\x16\x2c\x59\xef\x52\x1b\x50\xcc\xd6\x06\xf3\x66\x98\xa4\x36\xf4\x0a\xf3\x53\x23\x56\xee\xf0\xf3\xce\xd3\x32\x76\x5e\x49\xa3\x2c\x9f\xa0\x5b\x40\xee\x46\x4e\xb6\x02\x10\x86\x3a\x7a\x3a\x95\x1f\x70\x18\xa1\xaa\xcb\xb8\x68\x40\x35\x94\x40\x98\x24\x38\x80\x31\x1b\x2c\x08\xbd\x0f\x01\x13\x65\x95\x98\x6e\xf6\xc5\x28\x9d\x3b\x98\xb9\x20\xb4\x48\xff\x16\x30\x44\xe1\x8d\x2a\xa1\xcb\xa8\xdd\xad\xa1\xcc\x9b\xdd\x96\x92\xed\xd7\x2b\x39\x57\xef\xcd\xa6\xc5\x59\x1f\x70\x43\xd8\xee\xba\x6e\x9a\xa3\x15\x16\x24\x86\x8f\xfe\xec\xf1\xfe\xa3\xad\xf8\x4e\xaf\xbf\x57\xb2\x2d\xc2\x5f\xf5\xfb\x3f\x2d\x7d\x56\x74\x2c\x6a\x16\x41\xf7\xea\xdb\x6a\x60\xeb\x42\x21\x47\x36\x63\xb0\x36\xb3\x43\xb8\x6a\x01\x0c\x69\x72\x62\x03\xe8\x15\x96\x81\x98\xbc\x8b\xfc\x0f\xeb\x9f\x26\xd7\x99\xad\x5f\x88\xd8\xb4\x6b\xc6\xb9\x5c\x55\x24\xd0\xea\xda\xb7\x83\x34\x8f\x39\xdd\x7b\xe8\x19\x0b\x20\x23\xbe\xe5\xf9\xae\x91\xe4\x51\x30\x77\x3a\xab\x9f\xda\xf7\x1c\x42\xc8\x10\x5e\x44\x99\xb9\x9e\xa7\xeb\xd3\x1c\x96\x48\xa1\x16\x54\x23\x75\x66\x0d\x06\xcc\xa4\x62\xe9\x49\x4b\x72\x89\x4e\x67\xc8\x45\x93\x50\x2d\xad\xa9\x3c\x2e\xf0\xd7\xdb\xaf\xdb\x5a\xd1\x5f\x2c\x6c\x46\x7c\xe0\x23\xa9\x7b\xe2\x0a\x8d\x26\xe6\x75\x0c\xc8\x66\x40\x44\x4d\x25\x22\x3b\xf4\xc1\x7f\x66\x47\xa1\xf3\x77\x55\x9b\xc2\x4c\x9b\x83\x00\x38\x05\xa3\x26\x00\xc9\x2f\x6f\xba\xdf\x29\xca\xf7\x0c\xe8\xb5\x5b\xc1\xb6\xba\x1a\x75\x8e\x13\xc3\xf5\x9a\xca\x88\x4d\x5c\xca\xe0\x88\x71\xbe\x7e\x0d\x65\x70\xe4\x4f\xa7\x5e\x12\xe7\x96\x63\xfe\x6d\x7e\x7f\x2a\x98\xf5\xa2\x31\xa7\x2c\x2f\x6e\x8b\x8a\x95\xbe\x2b\x03\x18\x5d\x05\x60\x68\xa4\x21\x08\x74\x40\xf9\x6d\x26\x7d\xb5\x19\xd1\xce\xf8\x6b\x72\xd6\x1c\x8d\xb3\x99\x56\xd0\x2d\x7d\xa7\x65\x0f\x27\x3e\xa5\x8d\x16\xe9\x34\xb8\x4b\x90\xe2\x2e\x3e\x9d\xb9\x50\x42\xf1\xa9\x4a\x1a\x24\x72\xc3\xd4\x22\xed\x7e\x2a\x02\xdf\xe0\x9d\x6d\x13\xdb\x93\xe5\x19\x01\xbc\x4e\x77\x69\x9a\x9c\x96\x54\xdc\x7e\x21\x05\x42\x3c\x9c\xa7\x68\x89\xac\xe9\xdc\x77\xdc\xd5\xbf\x6d\x35\xef\x3c\x77\x7a\x00\xf5\x1f\x48\xe6\xaf\xe9\x18\x77\x43\xc4\x92\xd1\x4f\x5f\x0d\xbc\xe9\x5b\x95\x7c\xa3\x4a\x2a\x4f\x35\xa0\xc4\x49\x6f\x8a\x9d\x2b\x72\x55\xc0\x45\xa7\x5f\xe9\xfd\xa9\x3d\xad\x7b\xfd\xee\xf2\xca\x31\xe9\xe5\xa4\x13\xbc\x1e\xe8\xe9\x9d\x95\x9d\xfe\x29\x4e\x83\x13\x59\xc4\xc7\xad\x1c\xf1\x74\xe0\x85\x3f\xc8\xe5\xe9\xe6\x5b\xef\x6a\xdd\x98\x3c\x7a\xb0\xc0\x6c\xe2\x11\x73\x76\xa3\x96\xb2\x5d\x11\xcc\x37\xf1\x76\x1b\xd6\x0d\xa0\xc9\xe7\x66\xf6\x87\x5e\x68\x75\x0f\xf0\x6c\x61\xd1\xef\xc8\xec\xc4\x25\xaa\x79\x20\xba\xc5\x1e\x36\x7e\x8b\xa0\x1c\xaa\xc1\x96\xeb\x59\xc7\xe2\xb9\xb0\x0e\x93\xb1\x9c\xb9\x40\x2a\xa3\xe4\x58\x30\x5b\x68\xf1\x32\xa6\x11\x92\xe7\x5b\x30\x35\x23\xf9\x5e\xb3\xda\x2a\xdb\xa3\x23\x9f\x80\xda\xec\x8b\x80\xc3\xb4\xb3\x62\x12\x41\xba\xd1\x37\x4f\x4f\x47\x17\x5b\xad\xef\x87\x94\xd4\x60\x19\xe2\x10\x3d\xd5\x51\x64\x63\xa0\xc4\x13\x3e\x64\x25\xd2\x07\x5a\xca\x74\x11\xe8\xda\x04\x9c\xfe\x05\x64\x88\xea\x94\x2e\x9b\x74\x89\xd2\x32\x54\x16\x50\x9d\xfc\x21\x73\xb5\xc1\x8c\x7a\x5d\x05\x21\x52\x85\xc3\x92\xd0\x90\x96\x90\xf4\x99\x07\x90\x87\xc1\xb4\xb9\x2a\xb7\xe9\xca\xdb\xb7\xd5\x6d\x30\x0b\x5b\xf3\xa0\x4f\x0f\x03\x1f\x9d\xd5\xc8\x9d\x64\x32\x54\xd5\x75\x8d\x64\xe4\xda\x14\xf4\xcf\x1b\x48\xd0\x22\x10\x39\x44\xce\x98\xf5\xa7\x1f\x06\x9e\xe1\x6f\xe6\x2f\x18\xff\x3f\x00\xa8\x4d\xe0\x79\x1b\x1c\xd3\x31\x41\x63\x04\x80\x3e\x99\x45\xf4\x51\xf6\xf8\xde\x8f\x6b\xde\x11\x6c\x7e\x7b\x7e\x3c\xa9\x7a\x2d\x9c\x81\x0d\x41\xd1\x20\xe6\x86\xe8\xc4\x1a\x65\x5c\xd7\x4c\x9c\x04\xbc\xee\x83\x2f\x6a\xa0\x09\xa1\x13\xa6\xc7\x81\x22\x3e\xf4\xc8\x76\xde\x08\xf4\x39\x85\x0f\x46\x01\x05\x07\x81\x08\x8d\xae\xad\x82\xe8\x04\xa7\x60\xd7\xbf\x78\x81\x47\x3b\x2a\x92\x61\xe4\x02\xd6\xfd\x33\x70\x2d\xea\x34\x4d\x3c\xa7\x14\x24\xc8\x39\x51\xcb\x4d\xdc\x63\xf5\xd8\x38\x1e\xc6\x4f\x45\xd4\x60\x8d\xaa\x79\xd3\xcc\xe3\x02\x29\x34\xb8\x32\xee\x2d\xd3\x40\x30\x8d\x0c\x42\x81\xcb\xca\xd2\xc7\xde\x5f\x79\x81\xee\x21\x1a\x0a\x12\x23\x13\xf8\xd4\x66\x99\x3d\x97\xfb\xa8\xa3\x88\xdf\x8b\x1a\xda\x4a\x3d\x6f\x49\x5a\xff\x0f\x73\x5f\xd6\xe3\x26\xf6\x6d\xff\xde\x9f\x02\x55\x4b\xff\x17\xfe\x65\x66\x1b\xaa\x93\x48\x98\x19\x33\x98\xc9\x18\xbf\x5c\x61\x66\x9b\xc9\xcc\x90\xdb\xdf\xfd\xca\xae\x4a\x52\x49\x27\xfa\x0d\xea\x87\xb6\x64\x03\x87\xbd\xf7\x5a\xac\xb3\xcf\x3e\xe7\xc1\xc0\xf6\x4a\x97\x99\xa8\xf3\x75\x0a\x5e\xd0\x88\xc1\x9b\x36\xac\xb6\xb8\xd2\xf2\xfd\x59\xc8\x21\xf1\x46\x9a\xdd\xe0\xb9\xf5\x64\x1b\x19\x81\x56\xc8\x65\x70\x33\xc1\xf3\xcd\x93\x02\x43\x7e\xcf\x26\xfa\x95\x81\x4e\xe4\xd6\x53\xd0\xfd\x6d\xca\xc2\x1a\xe1\x4f\xd7\xb4\x62\xa7\x3a\xf2\x8f\x34\xe4\x5c\xfa\x0b\x84\x8b\x95\x3e\xed\x76\x97\x4c\xcf\xa2\xeb\xc6\x74\xac\xd4\xd4\x0c\xd7\xd7\x3c\xde\xe8\x55\x3f\x6e\x3c\x66\xca\x46\xbc\x5a\x4e\xbb\xf8\x76\xf6\x64\x98\x1b\xcc\x30\x47\x58\x63\x9e\xed\x96\x3c\x32\x9a\x4d\xaf\x1d\x4e\x51\xc7\x81\x9d\x95\xfa\xe4\x4a\x27\x4d\xcb\x35\x25\x37\xf4\x1d\xaa\xa8\xb2\x29\x83\x04\x7d\xed\x4f\x88\xb5\x61\x78\x7e\x91\x97\x2b\xb1\x16\x4a\xe7\x62\xb8\xb9\x77\xbd\x31\xd5\xd6\xe5\xcf\x55\xc9\x1d\xbc\x40\x51\x68\x3c\xd4\xca\xed\x1a\xc5\x05\xa3\x65\xb7\xae\x94\xc4\x27\x99\x4b\xa6\x6b\xc5\xa4\x8b\xc5\xbb\x43\x89\x1f\x6a\x23\x2a\xd8\x02\x3d\x8c\x47\xa3\x3d\xca\x23\x8f\xa4\xeb\x00\x4c\xa6\xdc\x20\x2e\x89\x95\x71\x0e\xd7\xc1\x63\x28\x45\x9b\x4e\xe5\x2c\xb0\xe4\x04\xd4\x67\x94\x4c\x56\x75\x49\x72\xa5\xfb\x94\xcd\x72\x9c\x42\xab\x4e\x33\x9a\x7d\x90\x1e\xe8\xd9\xde\x65\x85\x33\xea\x1b\x42\x2e\xd6\x07\x1e\xdb\x0e\x9b\xac\xd0\xfd\x0b\x38\x85\x1b\x87\xdf\x1d\x2c\x68\xbb\x97\x79\xe4\x0c\x71\x78\x97\xd8\x0d\x87\x53\xf2\x1a\xd6\x89\x6b\x10\x55\xda\xad\x1a\xb3\xbe\xf7\x76\x3e\x99\xa4\xe2\x91\xc6\x49\x87\x52\x6d\x94\x36\x92\xd9\x1c\x6c\x3b\xe5\x30\xf8\x6c\x64\xbe\x25\xf8\xf8\xac\xa8\xb2\xc6\x57\x20\x7b\x83\xd0\x40\xec\x70\xc6\xcb\xc7\x99\x8f\x51\x6b\xbd\x15\xc7\xb1\x51\x47\xc8\x1f\xd8\xb3\x49\x30\xc8\x75\x93\x22\x9e\x81\xef\x44\x8c\x2e\x62\x90\x0e\x4e\x33\x77\x3e\xed\x07\x8a\x91\xba\xc5\x60\x91\x9c\xe2\xce\x9d\xa7\x5f\x86\x0d\x3e\x40\x21\xa6\x53\xa6\xba\xb7\xd9\xa6\xe5\x46\x41\x72\x35\xf2\x86\xce\xd7\xcd\x51\xf3\xcc\x96\x92\x1b\x73\xc0\x0e\x38\xbd\xa5\x59\x4b\x30\xd7\x91\x01\x43\x9a\xf1\xb7\xae\x3e\xa6\xbc\x9d\xfe\x61\x55\x22\x7f\x7f\x2f\xf2\x8d\xe7\x38\x67\x7f\x38\x86\x7b\x0f\xea\x23\xf7\x24\x55\x99\x77\xca\x2c\x6f\xe7\xa5\x72\xb0\xe6\xce\x61\x2f\xea\x69\x92\x5d\x2a\xac\x83\x46\x11\x59\xd6\x5b\x58\xa6\x53\x7d\x56\x25\x25\x9d\x2a\xfc\x2a\x0b\x57\x84\xb6\x6c\x7a\x1a\x5d\x1e\x56\xeb\x9a\x08\xc5\x80\x1a\x78\x67\xf1\xc6\x2c\xf4\xab\x5b\x71\x03\x49\x8a\xa0\xa6\xe5\xbc\x08\x9d\x16\x4c\x6b\x6a\x6f\x5b\xe8\x9a\xb3\x0b\xa3\xb3\xa8\x06\x17\x67\x68\x1a\x36\xaa\xbb\xb9\x1c\xc0\x2e\x25\xe6\xe5\x10\xf8\xde\xfe\x08\x81\xa0\xd4\x51\x3d\xae\xd1\x03\xc8\x1c\xcc\x75\xb7\x75\x1c\xfb\xa6\xca\x2d\x1b\x98\xcb\xe5\xa4\x9f\x54\xd2\xa5\x4e\xca\x6e\x02\xa1\x23\x7b\xc6\x23\x02\xba\x8a\x84\x54\xc2\x79\x2d\x79\xae\xe0\xf8\x0c\xec\xd9\xa7\x72\xcb\xd0\xdc\xae\x3a\x98\x98\x82\xad\x2b\xb6\xda\x68\xe7\x36\xc9\x4f\xe3\xf9\xc6\xae\x33\x63\xa7\x1f\x79\x35\xd8\x39\x87\x78\x7b\xdd\xd2\x95\x91\xe6\x2c\x31\x4d\x2a\x5b\x43\x62\x63\x0d\xd8\x0d\x91\x13\xcf\xc5\x16\x78\x82\x77\xc7\xe5\xca\x78\xb2\x6f\x9e\xf2\x4b\xd3\xa3\x98\x2f\xba\xf6\xa2\x64\x7e\x41\xcf\x73\x37\xc0\x3a\xe5\x78\x61\x4c\xec\xe9\xe6\x96\xd7\xf5\x36\x56\x9d\xb8\xc7\x2b\x5a\xe1\x9a\xdb\x69\xbb\x0b\x9c\x49\xe5\x4d\x46\xe4\x6a\x98\x4d\x5c\x42\xa9\x70\x8d\xd2\x24\x0d\x09\x79\xf8\x78\x6c\x0f\xbc\xee\xcc\x7b\xd9\x5e\x2a\xd0\xdd\xd2\x1a\x9b\x85\x97\x9a\xec\x12\x51\x10\xb0\x00\x66\x4b\x19\xef\x25\x33\xc6\x03\x9d\xd9\xfa\x2e\xb1\xbb\x78\xe4\x74\x3d\x29\x1b\x74\xaa\x65\xca\x08\xf8\x85\x38\x1f\x6e\xa2\x23\x0b\xe2\x49\x41\xbd\x4e\x2b\x76\x19\xbc\xf6\x98\x39\x3b\xf0\x67\xbc\x85\x06\x6e\xa7\xda\x74\x8c\xd4\x78\x14\xea\xc2\xba\x50\x33\x64\x31\xd7\x23\x57\x87\xce\x78\x04\x07\x85\xed\xae\xcc\x22\x56\xbb\x4d\xdd\x05\xea\xda\x9f\x95\x42\xf0\x2f\x43\x17\x4d\xf8\x3e\xcf\xe6\x4a\xba\xf2\xe6\xa5\x70\x38\xda\x8a\xf2\x2d\xda\x1c\x0d\xd3\x8a\x2f\x0e\x63\x53\xfb\xdc\xad\x0b\x17\x45\x32\x5b\x58\x18\x7a\xe6\xae\x4e\x36\xed\xcd\xdb\x31\x8d\xd0\x03\xbe\xec\x82\xe5\x1c\x16\xf3\x39\xb9\xd6\x32\x1c\x08\x7a\x4f\xaf\x3d\x54\xb5\x99\x76\x57\x65\x84\xd8\x6a\xbb\x8d\x86\xa9\x1a\xd8\x8f\x9e\xef\x9e\x27\x2f\xae\x14\xe5\xba\x84\x53\x10\x8d\xeb\xbc\xf1\x5c\xff\x94\x16\xe4\x5e\x14\x05\x6c\x89\xe3\x1a\x71\x46\xd9\x12\x17\x6a\x18\xae\x0e\xb9\xaf\xc2\x73\x60\x78\x9e\x67\x11\xf9\xe4\x5d\x27\xfb\x2a\x84\x07\xd6\x08\x0f\x88\xdc\x22\xb7\x7d\xe2\xb1\x6b\x59\xea\x25\x6e\x93\xb4\xc7\x43\x14\x4b\xa9\xd4\xab\x30\x71\xdd\x84\xa3\x7a\x8e\xd4\x22\x25\x37\x3e\x42\xf6\xb1\xa4\xfa\x07\x6f\xae\x9b\x46\x56\x92\x4b\x84\x6a\x0d\x88\x74\x8b\x77\xa4\xb5\x92\x2d\x1b\x6c\x31\x53\xf1\x82\x6d\x0e\xc3\x8c\x8e\xf5\x51\xec\x34\x3a\x24\xa0\xd1\xf0\x68\x76\xed\xaa\xbd\x8d\x32\x63\x75\xf8\x7b\x2b\x44\xf1\x0f\xfb\x67\x41\x96\xbf\x7b\x87\xc6\xeb\x2d\x47\x53\x0a\x26\x98\x8b\x76\x88\x00\xb7\xdc\x6d\x96\xac\xb9\x74\x78\xb9\xb5\x74\x2b\xd5\x46\xc6\x2f\x32\xef\xc4\xb1\x98\x92\x48\xd7\xa0\x9f\x2a\x0d\xca\x98\x53\xb4\x3f\x65\x9e\xc0\xa2\xbe\xc0\x82\x19\xcc\x13\x3b\x95\x49\xa7\xfc\xe0\xfb\x57\x7a\x87\xce\xd7\x80\xee\x40\x77\x09\x95\x7e\xb3\x5c\xa7\x0a\x73\x4f\x0a\x5e\xf7\x64\x71\x8c\x8b\x28\xf2\x30\x92\x24\xfa\x64\xbd\x69\xaa\x3d\x9f\x12\xe5\x10\xac\xd1\x82\x4a\x2f\x95\x09\x12\x8a\x5a\x6f\xd4\xe6\xea\xc5\xd8\x06\xbe\x1d\xba\xa0\x02\x0f\x1d\xe3\xf0\xf5\xf9\x02\x5e\x04\x13\x94\xcf\x6e\xb9\x59\xeb\xb3\x41\x46\xfb\xb1\x3d\xd1\xb6\x71\x26\x4d\x28\xf5\xcb\x53\x22\x69\xc9\x85\x92\x6e\x51\xbf\xe5\x99\x11\xd9\x75\x94\xae\x6e\x4b\xcd\x65\x5a\x14\x3f\x8e\x57\x01\x32\x76\x9e\xc3\x65\xc2\xe5\x40\xef\x8d\x2a\x86\x9a\x1b\xbc\x21\xb1\xda\x4a\x39\x1b\x73\x14\xa3\x22\xa7\x05\xce\x2c\x82\xf7\x69\xad\x68\x44\x43\x44\xd9\xea\xe6\x81\xac\xa5\x58\xcb\xda\x5c\xa2\xc0\xcd\x4b\x96\x9a\x0b\x07\xdf\x28\xde\x25\xc4\x75\x62\x7b\xbc\xb1\xb6\x80\xf3\x2a\xa6\xd5\x36\x77\xad\x43\x99\x68\x46\x98\xae\x46\xc5\x54\xcf\xa9\x13\xd7\x04\x99\xd8\xba\xcf\x42\x8e\x58\x68\xc6\x5e\x5a\x7b\xc5\xb0\x73\xcd\x23\xb2\x70\x96\xe8\xc8\x50\xb5\x6d\xd1\xb2\xd8\xfb\xa0\x9a\x8c\xf0\x49\x52\xb1\xee\x34\x0b\x95\x3c\xce\xc9\x62\x68\x5b\xf4\xa2\xcd\xb2\x74\x3a\x6e\xb2\x2d\x9c\xd7\xfb\x4a\xdd\xc0\x8e\x50\xec\x8f\xe4\xc2\x38\x60\x23\x90\x1a\x7b\x98\xc4\x31\xcc\x18\xa2\xd8\xb5\x7b\x87\x77\x34\x28\x19\x3a\x45\x89\x31\xaa\xe5\x97\xc3\xcd\xd7\x30\xaf\x61\xd6\xf6\x65\xeb\xf7\xb7\xf4\x98\x6a\x34\x62\x1b\xd5\x2d\xaf\x0e\x1b\xd6\x07\xeb\xcb\xe9\x86\xf0\xed\xd1\x61\xfc\x82\x47\xa9\xcb\x5a\x19\xbc\x34\xc6\x32\xc9\xba\x2f\x27\xf9\x81\x62\x4f\xd1\x50\xf5\xa9\xb9\x2c\xfb\x58\x17\x40\x2c\xad\x69\xca\xa1\x9c\x39\xab\xf4\xdc\x96\x37\x35\x1f\xd9\x8c\x61\xad\x4d\x61\x91\xa2\xf3\x1c\x83\xd5\x42\xd4\xd6\xe2\x76\x85\xe5\x22\x9c\x4e\xd5\xe9\x60\xc0\x70\x9b\x6f\xcd\x0e\x22\x6f\x26\xc6\x56\x6e\x78\x3c\x67\xc1\xe2\x64\xf6\x12\x12\x28\x0b\x76\xa1\x52\xcc\xf6\x16\xc1\x8b\x09\x69\x54\x7a\x77\x08\xcc\x9a\xa3\xed\x4b\xd3\xf6\x5c\x1e\x45\x90\x78\x14\x8a\x92\x37\xe7\xad\x2e\xb0\x18\xcc\x40\x25\xc7\x5e\xb4\xa4\xdd\x30\x6c\xdd\x7a\x45\x29\x0a\x98\xb7\x8f\x92\x2d\x33\x88\x2d\x55\x79\x71\x41\x96\x02\x15\xca\x3e\x71\xc4\x77\x24\x4d\x1b\x8b\x71\xc4\x77\x96\x86\x8d\xc1\xdf\xfb\x37\xa1\xf9\x9f\x36\x98\xc3\xe9\xdb\x2b\x04\xf2\xb7\x47\x1e\x9e\xd5\x4d\x41\x78\xf0\xa9\xee\x7a\x14\xa1\x47\x77\x4c\xbd\x3a\xb6\x58\x3e\x05\xaf\xc3\x60\x86\xa4\x06\x8b\x31\x2e\x41\x93\x1b\xc6\x90\x81\x10\x24\x0f\x1b\x95\x01\x32\x87\x96\xdf\xf9\x8a\x65\xd4\x1d\x14\xd6\xc5\xb0\x74\xb6\xbe\x2c\xd7\x79\x1d\x44\x9d\x5e\xbb\xc1\xe9\x34\x9c\x75\x4c\xd5\x09\x02\xc1\xad\x69\xe1\x1c\xac\x21\x36\x10\x26\xd4\x6e\x9e\xab\x50\xb7\xc7\x5b\x05\xb3\xfd\xc6\xd4\x8f\xbd\x55\x41\x96\x2b\x0f\xc7\x0d\xe2\xf4\x24\xcc\xc4\x69\xde\x40\x36\xee\x84\x2e\x4f\x1f\xe2\xb0\x2c\x5a\xdb\xe9\x86\x70\x8f\x11\xba\x33\x1b\xbb\x43\x29\x27\x47\x76\x6b\x07\x17\x2a\x0b\xe8\xd6\x8e\x14\x7f\xda\x5c\x20\x98\x40\x6f\x2a\x89\x38\x97\xd1\x45\x0c\xf9\xc8\xa5\x2a\x0f\xdf\xbc\x52\xa3\xe0\x38\x2c\x87\xb0\x4a\xbc\x62\x90\xf7\x0e\x0c\x1d\xb6\x74\xcd\xe2\x69\xc0\x36\xae\x19\xcc\xd9\x35\xde\x22\x9b\xb6\x59\x12\x77\x73\xa6\xcc\x14\x19\xb8\x61\x62\x73\x09\xef\x0e\x73\xe7\x6f\x2d\x8e\xeb\x0a\x37\x85\xa7\xd6\x51\xc7\x7a\x2c\xdd\xcb\x8d\xce\x83\xa9\x4a\x32\x31\x44\xc6\xcc\x98\x99\x9e\xdc\x64\x12\x04\xb6\x72\x17\xaf\x41\xed\xd8\x26\x75\xb8\xe1\x5d\x46\xdd\x12\xf0\x6e\xb8\x7a\xaa\xa0\x9e\x95\xf0\x94\x28\x79\x7c\x01\x77\xd4\x0e\x07\xf9\x92\x37\xd0\x69\xe3\x96\x9d\xd4\x12\x30\x7d\x2e\x32\x61\x54\x24\xa5\x03\xaf\x20\x37\x2c\x83\xa5\x49\xe2\x12\x66\x49\x28\x43\x74\x71\x34\xcc\x34\x13\x07\x62\xaf\x5b\xa3\x57\x08\x60\x70\xdb\x1f\x2a\x58\xbc\xb1\xd3\x85\xec\xed\x1d\x3a\x94\x88\x18\xfb\xa0\x5c\x84\xd2\x75\xe8\x4e\x10\x1e\xeb\xfb\xa3\x83\xb9\x7b\xb6\xe6\x23\xcd\x3d\xcc\xce\xae\x99\x99\x4c\x12\x54\x0d\x5f\x5a\x91\x22\x93\xb9\xc0\x18\x29\xd0\xed\xd1\x06\x8f\x62\x78\x6c\x42\xc3\x10\xe9\x53\xd5\x71\xe4\x75\xbb\xaf\xad\xdb\x5e\x13\xbb\xad\xde\xe0\xa4\xe8\x14\x8a\x1e\x1c\x4d\xd9\xa6\x42\x57\x53\x05\x4f\xe6\xcf\x33\x85\xd4\xa2\x4e\x0f\xfe\x7c\xb5\x7c\xc9\x4e\xc0\xf3\x18\xc5\x61\xda\x74\x11\x6b\xda\xaa\x35\xce\x0d\xcf\x24\x12\x49\x72\x30\xb1\x16\x67\x10\xa7\x53\x34\x38\x1a\x27\x05\x33\xef\x6b\x6a\xc5\x89\x36\xf1\xed\xe8\xf2\xda\xfa\x6f\x9d\x31\x97\xec\x1f\xf6\xb4\xf0\x82\xfa\xf6\x9a\x76\xb8\x1b\x60\x98\x76\xd2\x00\x54\xbd\x75\xa8\x17\x49\xc4\xcb\x09\xc2\x57\x87\x43\xed\xb8\x39\xcf\xc0\x2d\x2a\xf1\x3c\x72\x99\xb6\xe7\x74\x77\xc1\xb7\xd6\xe4\x85\x6d\xb0\xf7\x02\xae\x30\x0a\x89\xbd\xc1\x49\xcb\x99\xd2\x21\x9b\x71\xbb\x66\x37\x07\x7e\xe1\x11\xb1\x22\x2e\x11\xea\xe3\x5d\xaa\xdf\xb4\x34\xaf\x09\x75\xc1\x97\x3e\x5c\x96\x1a\x1e\x6b\xd3\x66\xc8\x78\xdf\x5c\x61\xc8\x66\xd6\x60\xcc\x76\x5e\x16\x28\x22\xb5\xb1\x91\x5d\x80\x0e\x06\x1b\xb4\x60\x23\x62\x91\x43\x4f\x87\xa5\x2c\xe1\xb8\x44\x58\x53\x25\x39\x30\xd3\xc3\x81\x08\x3a\xec\x58\x9c\x84\xf5\x7c\xc8\xb5\xcb\xba\xad\x72\xe7\x9c\x1c\xec\x0e\xbe\x11\xbc\xd0\x1d\xd7\xc3\xf1\xc6\xac\x0f\xd7\xdc\xe6\xc0\x1d\xad\x43\xba\xce\x8a\x96\x64\xec\x4d\xa3\x6e\x8f\x0c\x78\xbd\x72\x0b\xca\x29\x34\x3c\xb7\xdd\x40\xe2\x9d\xb2\xcc\x7d\xd0\x9e\xdd\xed\x9c\xb5\xb4\x10\x83\x06\x6d\xa1\x0c\xc3\x9a\xa6\xa2\xca\x6a\x31\x31\x60\x46\x32\xf8\x25\x54\x98\x02\x5a\xd4\x8d\xae\xef\x78\xa1\xee\x02\x7d\x0d\x6d\xed\x5a\x86\xe7\xc8\xd8\xc2\x1e\x58\xc4\x3b\xa3\x3f\x9d\x04\xf8\x62\x24\x91\x79\x76\xc9\x63\x58\x15\xd5\xb9\xa5\x14\x8d\x6c\x83\x00\x74\xf6\xa2\x36\xe3\xec\x78\x23\xa5\xfc\x52\x75\x92\x64\x70\x05\x41\x41\x66\x65\xcd\x2a\xc2\xec\xae\xc7\xdd\x49\xdb\x16\x9b\xab\x74\x48\x66\x75\x3d\x26\x74\x69\x25\xe6\x8e\x1a\x6e\x46\x2c\xee\x33\x95\x67\xc5\xdb\xcc\x1f\x5a\xc5\xa4\x98\x02\xae\x70\x6f\xa9\x68\xda\x6a\xac\x0b\x13\xe5\x46\x6c\xee\xcf\xc8\x21\xc0\x6f\x25\xcc\x79\x84\x82\xba\x94\xc0\xf9\x5b\x25\x98\x8c\x84\x17\x6b\xe1\x7c\x55\x25\x56\x5e\x53\x11\x38\x5e\x64\xf2\x70\xbc\x99\xc9\x2e\x0b\xe1\x66\x13\x77\x46\x38\x5d\xcd\x96\xb2\x6e\x34\x7a\x4d\xe8\x02\xc1\x2d\x4b\x32\x52\xaa\x4f\x7b\x45\xd8\xab\xe5\x4e\x6e\x21\x62\x77\xeb\x15\x64\x82\x35\xd8\x64\xda\x6c\xc9\x92\x8a\xf5\x95\xdb\x36\x14\x2b\x35\x9b\x87\x26\xdf\xb6\xe2\x61\x42\xc6\x3a\x65\xf1\x2d\x13\x8d\xd5\x6d\x12\x76\x3b\x76\xa4\x93\x4e\x9f\x49\xb9\x8f\xbd\xfe\x0a\x12\x49\x95\x0b\x82\x2f\x9c\xc6\x00\x69\x25\xa1\x62\x17\x8c\xd6\xf7\x27\xeb\xa0\xf8\x62\x72\x18\xe7\xb0\x92\x59\x15\x11\x71\xf6\x6c\xe8\x6c\x9f\xa4\x5b\xcc\xab\x75\x16\xc7\xc5\xb8\x12\x93\xb2\xc7\xa3\x8d\x55\xc1\x3d\x9d\xc1\x6d\x27\x2a\x32\x46\xf7\x21\xb9\xa5\xce\xb5\xd8\xaf\x87\x7d\x65\xf5\x94\xdd\xb1\xf9\xba\x73\xfa\x8a\xcf\x24\x4f\x4f\x7a\x18\x44\x08\x52\xdd\x15\xfa\x54\x15\xdd\xcc\x62\x46\x06\x61\xaa\x6d\x6e\x32\x72\x07\x73\xac\x80\x08\xa2\x4e\xb0\x1c\x76\xc4\xd9\x41\xf3\xd3\x53\x2e\xeb\x23\x77\xd5\x69\x7b\x08\xf7\x01\x0a\x41\xe9\x84\x15\x47\x99\xc8\x79\xd9\xe7\xc9\x1d\x79\xb6\xba\x10\xf6\x84\xb8\xd4\xe5\xb3\x2a\x44\x13\x8a\x4c\xeb\xe0\xf1\x2c\x52\x3d\x97\xf6\xac\xbc\x34\x9b\x40\xf9\x9b\x0a\xc5\x6f\x00\xb0\x2a\xfd\xa6\xa9\x46\xe0\xf3\x98\x85\x5d\xfa\x02\xc0\xf5\xf4\xc7\xa3\xbd\xf6\xc3\x30\x2b\x13\xe0\x33\x50\xf8\x4d\x92\x95\x2f\x00\x02\x7f\x39\xf9\x7b\x1a\xf9\x61\xd4\x00\x9f\x7f\x03\x00\x00\xf8\x16\xfd\x05\xf8\x1d\x3e\x63\x3e\x81\xfd\xf1\x7a\xa2\x6a\xc2\xa8\x79\x3e\x57\x5d\x57\x15\x2f\x00\x5e\x4f\x40\x5b\xe5\x59\x08\xfc\xbe\xa6\x02\x3c\x08\x5f\xad\x82\x2a\xaf\x9a\x17\xe0\xf7\xf8\xf1\x79\x6d\xfb\x02\x09\xbf\x1e\xbe\x71\x79\x3b\x7e\x30\xc8\xab\xa4\x7a\xc3\x4f\xa3\x2c\x49\xbb\x17\x00\x23\xea\xe9\x7b\x77\x04\x7e\x6d\x79\xc7\xf9\xb9\x88\xca\xfe\xcd\xd1\xcf\xb3\xa4\x7c\xce\xba\xa8\x68\x5f\x80\x20\x2a\xbb\xa8\x79\xf5\x0f\xb3\xb6\xce\xfd\xf9\x05\x88\xf3\xe8\x17\x21\x01\x20\xce\x2b\xbf\x7b\x01\x9a\x3b\xf8\x5b\x4b\x55\x76\xaf\x02\x03\xc8\xfa\xab\xd9\xbd\x71\x7c\xa3\x48\xc0\xf0\x4f\xf9\xf8\x6f\x8c\xbe\x68\xf1\x4d\x9f\xbf\x9a\xbe\xf8\x41\x97\x0d\xd1\xff\x07\xfc\x97\x21\x6b\xb3\x2e\x0a\x7f\x70\xa6\xfc\x10\x0f\xcf\xbf\x70\x4e\xab\xe1\x6b\xc7\xfd\x55\xf9\x47\xcf\xbf\x73\x78\x88\xf3\x66\xfd\xb5\x4f\xea\x09\x20\xdf\xe9\x7a\xee\x93\x7b\x9e\x55\x4d\x07\xb4\x43\xf2\x63\x9f\x7c\x93\x2b\xcb\xf3\x97\xef\x7b\xfe\x35\xe2\x73\x57\xd5\x2f\x00\xfa\xcb\x88\xdf\x51\x7e\x8b\xf2\x03\xe3\xc7\x7c\x97\x05\x55\xf9\x66\xf5\x9a\xcb\x5f\xfa\xe0\x9b\x49\xea\xb7\xe9\x8f\x62\x51\xd4\x17\x9b\x0f\x50\xdb\xcd\x79\xf4\xe9\xbe\xdb\x65\x5d\x1e\x7d\xfa\xfc\x19\x58\xed\xfd\x2e\x05\xfe\xfc\xf3\x03\xf4\xda\xf4\xdb\x07\xe8\xae\xcf\xa7\xdf\x3e\x9c\xab\x70\x7e\xd8\x86\xd9\x00\x64\xe1\xc7\xa7\x57\xdd\x9e\x80\x20\xf7\xdb\xf6\xe3\x53\x53\x8d\x4f\x9f\x1e\x58\x0f\x8b\xb7\xd6\x27\xe0\x01\xf2\xf1\xe9\x35\x7d\xf2\x28\xee\xfe\x78\x97\xdf\x00\x72\x4f\xe2\xb7\x0b\x00\x90\xf5\x5d\xbe\xb7\x28\xef\x90\xee\xc9\xff\x15\xe7\x71\x65\x8f\x96\x4f\xff\xaf\x3c\xb7\xf5\x1f\x1f\xa0\x30\x1b\xde\x90\xdf\xed\x7e\x4f\xf3\xd1\xbd\xdf\x47\x7e\x8b\xf7\x63\xf7\x3f\x7d\xfa\xe0\x03\x69\x13\xc5\x1f\x9f\xd2\xae\xab\xdb\x17\x08\xba\x43\xae\xb2\xea\x09\xe8\xfc\x26\x89\xba\x8f\x4f\xff\x73\xce\xfd\xf2\xfa\x04\x34\x51\xfe\xf1\xa9\xac\xaa\x3a\x2a\xa3\x06\x28\xab\x26\x8a\xa3\xa6\x89\x9a\xa7\x4f\xf4\xb9\xea\x3b\x40\xda\xf3\xd6\x07\xc8\xff\xf4\x8e\xd7\x7f\x0b\xfe\x7b\x56\xb6\x9d\x9f\xe7\xff\x09\x09\xe9\xd5\xe5\xbf\xa0\xf1\x50\xee\x5b\x5e\x7e\x15\x0e\x00\xfe\xc2\x2f\xc9\xba\xb4\x3f\xaf\x82\xaa\x78\x50\x85\xc2\xac\x79\xce\xca\x30\x9a\x9e\xd3\xae\xc8\xa1\xac\x6d\xfb\xa8\x85\xfe\x13\xda\x5f\xb1\x00\xe0\xc3\x7d\x88\x4d\x45\x5e\xb6\xaf\x80\x2f\x10\x34\x8e\xe3\x6a\xc4\x56\x55\x93\x40\x28\x0c\xc3\x50\x3b\x24\x4f\xc0\x90\x45\xe3\xb6\x9a\x3e\x3e\xc1\xf7\x9c\x22\x57\x38\x80\x22\x4f\x9f\x3e\x04\x59\x13\xe4\x11\x10\x4c\x1f\x9f\x36\x2b\xe2\x09\x08\xe6\x8f\x4f\xf8\x8a\x7c\x02\x9a\x8f\x4f\xc8\x13\xf4\x9d\x01\x82\xac\x90\x9f\x58\xd4\xf7\xf1\x10\x7e\x7c\x52\x11\x74\xb5\x01\xc8\x15\x1e\x3c\xc3\x2b\xe2\x19\x79\x7c\xa9\x67\x74\x45\x3c\x63\x2b\xe2\xbe\x05\x9e\x91\xd5\x1a\x80\x9f\x31\x00\xb9\x37\x01\xe8\x8a\x10\xef\x4e\xcb\x77\x61\xc8\x15\x01\x50\xab\x8d\x48\x3c\xe2\x00\xf0\x8a\x7c\x86\x57\x1b\x00\x59\x6d\x1e\xdb\x3b\x08\x0c\xa0\xab\x35\x80\xac\x48\x00\x7f\x7c\x51\x80\x58\xa1\x07\xea\xc7\x48\x08\xb6\xc2\x1f\xa1\xa8\x15\x35\x6c\x56\x54\x80\xae\xf0\x67\x78\x85\xdf\x3d\x1e\x7c\xee\x5b\x62\x85\x32\x08\xbe\x42\x00\x04\x59\xe1\x00\x82\xad\x28\x00\xb9\xe3\x7e\x71\x5e\x7e\x54\x81\x58\x6d\x5e\x55\x40\xd0\x15\xf5\x73\xa1\x88\x2f\x42\x21\xc4\x0a\xff\x95\x09\xf6\x66\x02\xff\xc2\x04\xfd\x97\x38\xd8\xd7\x18\xbf\x82\xc1\xbe\x12\xf9\x0e\xe5\x9e\x12\xef\x12\x16\xf2\xbf\xa6\xfc\x4f\x2a\xc5\xb7\x9d\x73\x03\x7d\xad\x6f\x6f\xe3\x22\xa8\xf2\xe7\xa9\x7d\x46\xd0\x9f\x54\xb6\xda\x2f\xa3\x1c\x78\xfc\x3e\x87\x51\xec\xf7\x79\xf7\xd3\xfa\xf2\x6a\x71\x1f\x61\x59\x99\xbc\x1f\x48\x6d\xd7\x54\x65\xf2\x49\xba\x8f\x15\xa0\x8a\x81\xef\xaa\xef\xdb\xc9\xaf\xd6\x9f\x3f\x03\x59\x0c\xac\xc4\x7b\x45\xff\xf3\xcf\x6f\x41\xde\x01\x7d\x2d\xf9\xdf\x8d\xa0\x7b\xd4\xbf\x78\xbd\xaf\x03\x0f\x93\xa8\x0c\xbf\x19\x7c\x5f\x26\x3a\xff\x7c\x97\xfb\x15\xe3\xf5\xe0\xf1\xfb\xdc\x76\x4d\x56\x47\xe1\xfb\x4b\xea\x9a\xef\x06\x6f\x17\x7e\xf1\x7b\x5d\x75\x7d\x47\xec\x27\xe4\x1f\x53\xda\x63\xef\xad\x48\xfc\xb5\xc2\x7f\x61\xd8\x85\xbf\x40\x7a\x9b\x5b\x7e\x84\xfa\x52\xb5\x3e\x7f\x5e\x6d\xfd\xe0\xaa\x64\xe5\x15\xf8\x5f\xa0\x6f\x72\xae\x0d\xfc\x3a\xfa\xf3\xcf\xa7\x4f\xab\xd5\xbb\x54\xf9\x05\xca\xa7\xef\xdb\x3e\x40\xef\xaf\xf8\xf3\x67\xa0\xf1\xcb\x24\x02\x56\x4a\xd6\x76\xf7\xc5\xe4\x7b\xcd\xff\xa2\xcd\xbf\x23\xc6\xe7\xcf\xf7\x0d\xdf\x54\x05\x37\x75\xc0\x4a\xf3\x8b\x07\xd5\x7f\x5f\x96\x5f\xca\xf0\x96\x6b\xef\x34\x00\xee\x91\xef\x27\xee\x28\x8f\x24\xfc\x97\x6a\xdc\xad\xad\x6c\x79\xb5\xfe\x95\x30\x7f\x4d\xaf\x47\xfe\xfc\x7c\x1c\x7e\x80\x5e\xd7\x19\x1f\xa0\xfb\xec\xf1\xe9\xb7\xff\x0b\x00\x00\xff\xff\xe3\x97\xea\x96\xa3\x2f\x01\x00") +var _dirIndexHtmlDirIndexHtml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\xbc\xc7\x0e\xc5\x6c\x72\xa6\xb7\xd7\x55\xc8\x5a\xd9\xe0\x68\xc8\xc3\x4c\x8d\x5a\x00\x73\xce\x99\x1b\x83\x39\xe7\x4c\xc3\xf7\x6e\x74\xcf\x48\xdd\x80\x97\xf3\x2f\xfe\x15\xf9\x81\x38\xbb\xaa\xa7\xde\xb7\xaa\xce\xf7\xef\xff\x07\x67\xb2\x5e\x6c\xf1\xff\xdc\x1c\xe3\xf0\x1f\xff\xf4\xef\xff\xf9\x28\xd3\xe2\x3f\xfe\xe9\xdf\xc7\xf2\x48\xff\x39\x6f\xd2\x6d\x2f\x8f\xbf\xfc\xcb\x79\x54\xff\x4a\xfe\xcb\x3f\x83\xff\xf9\x61\x4a\xc7\xf2\x2f\xff\x72\xb5\xe5\xbd\xcc\xdb\xf1\x2f\xff\x9c\xcf\xd3\x51\x4e\xc7\x5f\xfe\xe5\x6e\x8b\xa3\xf9\x4b\x51\x5e\x6d\x5e\xfe\xeb\xdf\x0e\xff\xed\x9f\xdb\xa9\x3d\xda\x74\xf8\xd7\x3d\x4f\x87\xf2\x2f\xbf\xff\x0e\xfd\xcb\x7f\xfc\xd3\x3f\xfd\xfb\x7e\xbc\x43\xf9\x1f\xff\xf4\xdf\xdb\xa5\xda\xff\xf5\xff\xce\x86\x74\xea\xff\x9f\x2c\xcd\xfb\x7a\x9b\xcf\xa9\xf8\xd7\x76\x4c\xeb\xf2\xdf\xce\x6d\xf8\x3f\x8b\xf4\x48\xff\xed\x6f\x47\x70\x99\xea\xff\x91\xa5\x7b\x89\xa3\xff\xad\x0d\x18\xd3\xb9\x21\x55\xac\x67\x9a\xa6\x69\xc3\xf5\x1b\xde\xaf\x69\x9a\x66\xfe\x7a\xa4\x6d\x96\x8e\xff\xfa\xac\x48\x90\x6a\xfe\xfa\x22\x46\x8e\x10\x4a\x8e\x97\xc1\x09\x54\xc0\xc2\x9b\xd8\x0c\x93\x88\x54\x9b\xb8\x8c\x92\x85\xc2\x94\x04\xca\x10\x87\x0e\x96\xe7\xc3\x60\xfd\xf5\x07\x21\xa3\x38\xbc\xe0\x97\xc6\xca\xfb\xdd\x4f\x7b\x78\xda\x9e\x8a\x9f\x1e\xd0\xe8\xf0\xca\x7c\xf8\xe0\xbe\xac\xf2\xa2\xcf\x3f\xe2\x9e\xb1\xc8\xa1\x55\xb7\x02\x36\x1e\x58\x13\xc1\xc0\x4e\x67\xb6\x3e\x11\x73\xd7\xa0\x8d\x36\xb6\x05\x6a\x8d\xaa\x61\x53\x72\x32\xfb\x75\x8a\x55\x88\xe9\xe2\x7b\x7e\x3a\xd1\x7d\xc5\x15\x9c\x0e\xc6\xd5\xf1\x94\x00\x15\x45\xa5\x2d\x11\x1c\xd8\x41\xa9\xd4\x39\x9d\xa8\xa4\xdd\xa5\x8c\xac\x61\xfc\xc8\xb8\xc5\xcd\x7b\xf1\x42\x55\x93\x4f\xc7\x63\xa2\x28\x9b\x9b\xcc\x67\xd1\xc4\x58\xf1\xef\x29\xdd\x15\x31\x1d\x76\x8f\x76\xf9\xf4\xde\xe6\x23\x0f\xd5\x63\xb2\x46\x9c\x6a\x41\x9d\xe1\x79\x94\xf5\x5e\xd1\x28\xd1\x0a\xbb\xf2\x60\xe8\x2c\xf4\xc8\x6b\x23\xe5\x1f\x97\xb5\xa4\x19\x7c\x8b\xe6\xfa\x29\x14\x96\x99\x53\x8d\x6d\xad\x49\x6b\xf7\xe3\x73\x2b\x99\xee\x8a\xa8\x33\x4e\xde\xe2\xc0\x79\xf9\x76\x3a\xb7\x0e\xef\x3c\x46\x7a\x65\x62\x59\x83\x4d\xb0\x57\x3e\x3b\x70\x8f\x1f\x13\xea\xfa\x19\x0e\xad\x18\xec\xef\xf1\xe2\x47\xb6\x1b\x50\x1f\x1d\x7f\x18\x05\x9b\x47\xd6\xd0\x0c\x7f\xd3\xca\xc0\x5e\xd8\xff\x40\xe4\xa8\x95\x00\xba\xd3\xe0\xea\x05\x99\x2f\x93\x4c\x5a\x51\x7e\x78\xd5\x8f\x1e\xf9\xc8\x7c\xf0\x7a\xe2\x03\xe5\x0c\x99\x6f\xec\x1d\x85\x71\xac\x58\x4c\x18\x6e\x0f\x52\x73\x58\xdc\x3a\x50\x78\xf8\x0d\x52\xba\x04\xa1\xfe\x01\x91\xf4\x63\x1c\x13\x0a\xf6\x4c\x17\x12\x1e\x61\x39\x37\x51\xef\x32\xa9\x62\x39\xa8\x01\x2e\xc1\x2f\xa2\xa1\x44\x2e\x30\xef\xc4\xba\x41\x6b\x7e\xd4\x13\xac\xe8\xfa\xa6\xb5\x8c\xa3\xa3\x8a\xe0\x0a\xbb\xff\x5b\xa0\xb8\x7e\x60\x3a\x2a\xc6\xc6\xb2\xfc\x97\xff\xeb\x7f\xfc\x43\x00\x6e\xe5\x52\xa6\xc7\xbf\x4d\xf3\xff\x7a\xfb\xc7\x6f\x7b\xfb\x95\xff\xf6\xd7\x98\x4f\xdb\xe9\xff\xfd\x5f\x11\xbc\xa4\x75\xf9\xa7\x0a\xe0\xb1\xf9\x5f\x01\xbc\xec\xfe\x77\x5c\xd0\x8f\x8e\xad\xaa\x68\xcc\x17\x8c\xbc\x84\x84\x82\xe0\x17\xcc\xec\x3a\xd0\xf0\x67\xaf\x7e\x7d\xeb\x3c\xbf\x85\x0c\xad\x5d\xa8\xa8\x70\x15\xcf\x8d\x26\x2f\xed\x82\xb7\x06\xac\xc7\x3f\x74\xdb\xba\x32\x6c\xf3\xaa\xa2\xf2\x6e\x20\x08\x4c\x38\x43\xa8\xc7\xbb\xce\x57\xbd\x70\x4e\x68\x31\xd8\x6b\x47\x05\x17\x24\x80\x61\xd8\x77\xe9\x94\x91\xca\xbf\x79\x4b\xb1\xfd\xca\x5e\xca\x9c\x32\x9f\x67\x9e\x9a\x1b\x64\xb5\x0d\xbb\xc8\x2e\xb5\xf7\x47\x81\xd1\x8f\xd8\xf9\x23\xb7\x62\x78\x3b\x24\x97\xc2\x41\xe9\x84\x9c\x2b\x8a\xb4\x0f\xc8\xfd\x4f\x27\x89\xcf\x6d\x76\x19\xa6\xb8\x45\x62\xe3\x03\xe5\x71\x66\x7e\x50\x39\xf9\xbc\x29\xe3\x1e\x22\x20\x50\xb1\x6b\x4c\xb7\xba\x6b\x1e\x92\x60\x1c\x21\x55\xaa\x81\x48\x1a\x69\x25\x31\xc8\x3a\xef\x26\x6a\x3c\x1e\xe9\xf7\x06\x99\xba\xcc\x25\x43\x14\x95\xee\xaa\xec\x46\xae\xc6\x4a\x16\x38\x3a\x52\x96\xee\x3c\xeb\x96\x28\x3a\x59\x08\x64\xd4\x82\x96\x21\x3f\x6a\xc5\x86\x9e\x49\x28\xb1\xd2\x34\x21\xd8\xbc\xf9\x05\x0e\xfa\xc6\x65\x27\x96\x0c\x4d\xb6\x58\xeb\x7b\xfa\x84\x07\x05\xe5\x77\x59\x6e\x27\x30\x80\x28\x8e\xf6\x32\x5f\x13\xfa\xb7\x30\x28\x59\xf6\xf4\x74\x53\x20\x2a\x26\x0f\xa2\x41\xa8\x01\x8a\xb3\x77\xf3\x5d\x84\xe6\x86\x84\x5d\x83\x55\x75\x07\x2d\xc7\x0b\x99\x87\x9b\x7d\x1e\xcf\xc6\x62\xfa\x5c\x20\xc1\x1e\x05\x9e\x2e\xb8\xeb\x91\xf2\x40\x3d\x50\x45\x93\xfa\x0f\x0f\x1f\x51\xd2\x0a\xc4\x14\xb7\x6d\x7a\x28\xc8\x85\xed\xa4\x03\xfe\x5e\x93\x35\x34\xf3\xbc\xbb\x9e\xd7\x5a\x2f\x1b\x59\xaa\x50\xa4\x45\x4e\x45\xda\xdd\xb9\x7e\x16\x6c\x51\xb1\x6f\x29\xd4\x73\x29\x54\x62\x73\xf4\xbb\x9f\xd9\x5d\xf6\x7c\x9c\xef\x71\x60\x93\xa4\x6b\xbc\xd8\xb3\xef\x83\xdb\x3e\x42\xa2\xdd\xdd\xfb\x74\x01\xef\x8f\x92\xb9\xa0\xed\x36\xc9\x51\x83\xe4\x26\x7d\x9f\x6d\x7e\x6e\x2a\x34\x8f\xbd\xd1\x78\x5c\xdb\xba\x2d\xcd\x1d\xeb\x0f\xf5\xc4\xd2\xf4\xa5\x0a\xcc\x1c\x45\xa9\x54\xd1\x9b\xcb\x26\x1c\x0f\xd5\x6f\xa8\xd4\x82\xac\x8e\x97\x2f\xa8\x26\xaa\xfb\x86\xdc\xc3\x29\x0a\x34\x26\x77\x70\x7e\x70\x2a\xa0\x42\x20\x30\xad\xba\x78\x72\xc8\x63\xe1\xbd\xb4\x6d\x33\x48\x96\x18\xe4\x40\x1d\x04\x26\x0b\x0d\xa4\xe8\x7e\x11\xa8\xfb\xdc\xec\xbe\xb5\x3a\xf5\xd4\xa7\xd0\x11\xd7\x75\x1d\x2f\xac\xd4\xab\xa2\xb7\x4b\x32\x66\x98\xfa\xdc\x31\x68\xeb\xc9\x2c\x5b\x2e\x57\x84\x21\xb4\xcc\x57\xf6\x91\xfe\x5a\x9f\x1d\x67\xaf\x65\xc6\x82\xdf\x5a\xd8\xa9\x8b\x42\x15\x9a\x53\x99\xd7\x0c\x4c\x2b\xf0\xbd\xc1\x02\xf9\x3c\x43\xc7\xfd\x3e\x35\xab\x76\xc7\xe1\xd4\xaf\x8b\x82\xce\xa6\x0f\xd8\xa2\xd3\x8a\x81\x60\xfa\xba\x83\x02\xd9\x8f\xa6\xb3\x51\xeb\xd8\xad\x62\x5a\xa7\xfe\x43\x01\x91\xa6\xf9\x9f\x0a\x0f\xd3\x7f\xe1\x01\xf2\xfb\x9f\xc5\x43\x7c\x5c\x1d\xdb\x19\x0c\x17\xed\xf7\x4d\xc0\x5b\x33\x93\xef\xfc\xac\x39\x0a\x13\x43\x3f\xdd\x92\x3a\x76\x47\xf2\x6b\xae\x73\x0f\x44\x57\x45\x31\x30\xe3\x92\x9a\x79\x6e\x72\x73\xb2\x6e\x34\xe6\x45\xb9\x67\x1b\x60\xd6\x44\x46\x1d\x91\x84\x98\x12\xa4\x18\x4b\xf8\xea\xcc\xc6\xcb\xbb\x56\x51\xae\xe4\xb3\x2e\x53\x27\x41\x49\x84\x57\x04\xc6\xb8\x0d\xe9\xb5\x85\x88\x7f\x6d\xb6\xc8\x4f\xb7\xa3\x6a\x63\x33\x49\x75\x05\xf8\x4e\xa8\x58\x90\x41\x59\x57\xce\x15\x96\x0c\xb9\xf8\xee\xd6\x2f\xc5\x7e\x63\x5b\x99\xdc\x9b\x5d\x1f\x4f\x8e\x1f\x9b\x6d\xf4\xec\x71\xb2\xd7\xe8\xb3\x18\x25\x6d\x82\xc6\x6e\x7b\x6e\x15\x90\xfc\xa2\xf2\x64\x57\x85\x30\x3b\x60\x57\x91\xce\xce\x0d\x7a\xac\xc9\xa7\x17\x6d\xe2\x37\xc6\x65\x97\xd3\x0c\x4a\x5d\xcb\x58\x9e\x9f\x92\xe7\x03\x04\x14\x7e\x87\xab\x32\x7d\x55\x12\x6b\xd5\x88\x01\x9c\xf4\x85\x5e\x35\xc5\x98\x4f\xce\x8e\x15\xff\x9d\x16\x58\x97\xd3\x32\x96\x6b\xc3\xeb\xf5\x59\x94\x3f\x48\xb9\x47\x80\x3b\x7d\xf9\xf5\x0b\x6f\x58\x4f\x38\x7b\x67\xbd\x8a\xc0\xc2\x29\xb7\x91\x29\xf9\x47\xda\xbd\x36\x34\x5a\x04\x18\xf4\xe5\x73\x6e\xae\x6f\xc9\xef\x61\x65\xda\x1b\xbf\xac\xbc\xaa\x91\x1d\xce\xbe\xb5\x30\x43\x68\x94\xfa\xee\xbb\xd2\xf1\x4a\xcd\x6d\x0a\x73\x0e\x94\x75\xa2\xeb\xbb\xaf\x59\x3a\xc1\x01\xbf\xd0\x58\xea\xb8\x3b\x3b\x21\x97\xe2\x6b\x67\xa1\x4f\x18\x29\x46\x56\x9c\x41\x06\xb4\x50\x78\x9e\xb7\x4c\xb6\xe4\xd0\x3c\x0e\x24\x22\xda\xab\x1f\x26\x00\x82\x3c\xb2\x04\x81\xc9\x06\xad\x30\x8a\xdb\x07\x73\x38\x43\x76\x4c\xc5\x6b\xdd\x3a\x68\x92\x7c\x4e\x2a\x32\x7d\x71\xab\x48\x26\x3c\xa2\xe6\x24\x7e\xc5\x20\xce\x08\x3f\xe8\x43\xb1\xe2\xb1\xfb\x8f\x44\xd9\x71\xaf\xca\x2c\x27\x9c\xda\xa3\xd2\xf3\x27\x26\x77\xe1\xad\x8c\xb3\xc3\x42\xa6\x0d\x51\xd6\x5a\x05\xcf\xea\xac\x94\x16\x1d\x48\xa7\x5c\x94\x18\xc2\x5a\x16\xac\x7c\x4d\x4e\xee\xa2\xfe\xe2\xcc\x04\xd0\xb0\xd8\xe7\x8f\x37\x69\x2e\x25\x75\xfb\x42\x3b\x5d\xcb\x98\x10\x86\x7a\xc0\x8e\x37\x32\x68\xa3\x26\x33\x3e\x91\xab\x85\x9a\xeb\x4f\x62\x7a\x75\x08\x62\xda\x66\x36\x7f\xf8\x5a\x06\x8a\x6c\xb7\xad\xd0\x78\xb4\x9b\x7e\xaf\x0d\x59\xe9\xa9\x36\xd5\x1a\x2b\x0d\xa8\x0c\xf4\x47\xe0\x54\x5c\xb6\xf8\x5e\x2e\x13\x13\xdb\x71\xfb\xab\x9b\x81\x09\x55\x8c\xe7\xcc\x44\xdf\xdd\xd9\x0e\x48\xd8\xc5\xe4\xe2\xae\x17\x75\xda\xe0\xe0\x9e\x28\x1f\x7f\xaf\x9a\x9e\x2d\x00\x98\x7a\xeb\x93\x21\xc9\x70\x20\x84\x10\x9c\xf1\xc3\x23\xc0\x3a\x8f\x56\xba\x16\x2f\xa2\x69\x9e\x9f\x16\x32\xed\x56\x4a\xc1\x44\x50\xb1\x85\xb3\x8d\x8d\x4c\x5d\x06\x96\xc2\x50\x85\xab\xb8\x7a\x88\x84\x24\x83\x28\x37\xa2\x0c\xb7\xb0\x6f\x82\x3e\x78\xf7\x37\x4d\x8f\x73\x3a\xe4\xcf\x60\xd0\xbf\xbf\x65\x27\x3f\x08\x5e\xef\x9e\xf6\xc8\xb2\xff\x5b\xc8\x68\xff\x54\xc4\xe8\xb1\xbf\x0b\x0a\xe8\x77\xf1\x03\xef\x5b\x9e\xf5\x25\x2b\x43\xdb\xa9\x2b\xd8\xad\x12\xfb\xe3\xa0\xc6\xcd\xec\x09\xe8\x4f\x43\xbc\xec\x04\x6d\x10\xa0\xaf\x3d\x42\x98\x05\xac\xad\xfd\x0c\xb5\x6d\x7d\x57\x9b\xf0\xfc\x47\x3f\xe8\x4b\xf8\x1d\xb1\x38\x47\xb7\x71\x13\xf7\x45\x7c\x77\x5c\x1f\x6a\x84\x68\x37\x42\x50\x18\x81\x2d\xd8\x47\x10\x26\xf4\x9b\x9b\x10\x00\xb9\xa0\x21\xbf\x8e\x48\x63\xb5\xa9\x06\xb1\x10\xa9\x64\x17\x6f\xcd\x78\x8b\xaa\xaa\x83\x6a\xfb\x51\xb1\x74\xed\x7c\x0a\x24\x27\x38\x3d\x53\x31\x67\x98\x7b\xd8\x2a\x50\xbc\xdf\x95\x7c\xef\x0d\xd6\xea\x30\xea\x1d\x21\xbf\xb5\xa0\x03\xcf\x65\xe4\xe9\xb4\xa0\xe0\x81\x15\xf4\x3c\x46\x12\xf3\xc2\xbe\xcf\x98\x26\xac\xd3\x03\xc8\x50\x60\x6e\x65\xb8\xe5\x6b\xe7\x2c\x3d\x50\xa8\x43\x25\x22\x5e\x8b\x6f\x3e\x1c\x72\x27\xb4\x12\x9e\x47\xb2\xc6\x7e\x3c\xae\x8b\x5b\x63\xa6\x5e\x4b\x48\x6c\x9b\x99\x86\x51\x21\x04\x9e\xc3\xb0\x6c\xaf\x83\x48\x65\xdd\xab\xfc\xda\x86\x8c\x2b\x06\xa8\x83\x5c\x36\xb1\xcb\x8d\x9b\x7b\x89\xe0\x2d\xd2\x83\xd0\xf0\x0f\x63\xb0\x7d\x38\x83\x18\x0c\x43\xbd\x26\x00\xda\x63\xc0\x21\xd7\x76\x75\xf1\xe6\x49\xfa\x38\xc0\xd4\x05\xfe\xf4\x3e\xb2\xed\xfb\x83\x52\xef\x83\x8a\x95\x84\x41\xc8\x7c\x61\x8a\xd9\xa6\x13\xa5\xd0\x2e\x56\x64\xde\x6a\xb6\x18\x3c\x2a\x7a\x0a\x5a\xe2\x17\x8f\x6a\x24\x07\xb9\x34\xbc\xe9\xad\x86\x28\x2e\x15\xb1\x81\xdd\x7d\xc1\x80\x96\xbc\x4f\xe8\xb9\x2b\x58\x72\x44\xd3\x93\x59\x53\x5a\x3b\xdd\xba\xfc\x88\x80\xf9\x39\x07\xe7\xfa\xa1\x69\x5f\x7e\xca\x68\x82\xff\x29\x8c\xae\xc0\xdc\x3d\x5a\x75\xf1\x53\xee\x11\x0a\x67\xb7\x56\xaa\x8e\xbb\x36\x4f\x7d\x8e\x9b\x96\x5f\xbe\xa7\x4d\x1b\x6b\x7c\x10\x4c\x8a\x1a\x3b\xe7\x9b\x1b\x7c\x43\x9f\xee\x44\x0b\xa1\xdd\x3d\xfd\x93\x66\xe3\xe6\xb6\x9d\x5b\xb8\x94\xe7\x5c\xd8\x8e\x8f\x7d\x3f\xcf\xcd\x7e\x4e\xd5\xb1\x30\x87\x64\x8a\x7f\x5e\x5f\xd3\x79\x44\x37\x4f\x63\xde\xda\xce\xed\xd2\x6c\x20\x27\x6a\x62\x8a\xc7\x55\x01\x2b\xe1\x32\x35\x55\x9d\x5c\x20\xb5\x5c\xbb\x3e\xed\x09\x4a\x0f\x36\x41\x79\x89\x87\xa9\xdf\x2e\x14\xdd\x36\x42\x7f\x0c\x28\x6c\x83\x5a\x93\x36\x4c\xc8\x70\x97\x5e\xc1\x9c\x6c\x42\x7d\x73\xe8\x1a\xb4\x0b\xcd\xbf\xfa\x30\xa5\x02\xbd\x7d\x69\x07\x72\x10\xd7\xea\xd1\xa0\xd0\x82\xfd\xaa\xf0\x46\x56\x93\xae\x3b\xc9\x82\x0e\xf6\x4f\x4f\x5d\x0d\x3b\x7c\xf0\xd7\xaf\x74\xaf\xb3\x0d\x7c\xc4\x32\x40\x00\x7d\x43\x40\x79\x67\x65\x1b\x9a\xf1\x09\xf6\xeb\x92\x8d\xf4\x94\x89\xa1\x2c\x25\x5a\x3e\x24\x40\x69\x86\xb6\x4c\x3b\x50\x26\xd8\xc6\x21\xf1\x8f\xcd\xfc\xaa\xfa\x53\xe5\xfe\xfc\x5f\x6a\xa1\xf7\xa9\x63\xe5\x7f\xbc\x1f\x25\x63\xb2\xf0\x48\xea\x31\x5a\xa6\x08\x96\x77\x08\xbe\x73\xb8\xec\xd1\x6c\x84\xcf\xbe\xaa\x2a\x28\x20\x45\x4f\xc8\x5c\xe3\x74\x0d\xce\x51\x35\xfb\x1d\x31\xd7\x54\xba\xb3\x4c\xac\x7a\xb8\x2f\x5b\x52\x1a\x1e\xcb\x4a\x18\x3e\x9c\x26\x2a\xf6\x61\x77\x42\x3d\x8f\xbe\xe8\x77\xc2\x9d\xe5\xfd\x51\xcb\xb6\x21\x70\xd2\x9a\x20\xc1\x1a\x29\xf7\x20\xa6\x76\xe0\x95\xd9\x31\xab\x58\x83\xa9\xea\xb0\xb2\x3c\x2d\x24\xa0\x7e\x95\x2a\x11\xd5\x59\x4c\x81\x80\x91\x13\xff\xc3\xcb\x01\x00\x5f\x1f\x1e\x19\xc1\x0d\x13\x75\x09\x15\x35\xc8\x21\xb3\xf6\x99\x19\x82\x55\xd4\xe0\x46\x1f\x9f\x09\x4c\x7f\x80\xb0\x38\x29\xd9\x8f\x84\xb2\x35\x69\x70\x99\x7e\x8f\x54\xc6\xe9\x59\x07\x5c\xf1\x2d\xd9\x42\xfd\x56\x71\xa0\x55\xd1\x7b\xc8\x82\xfd\x51\x60\xb8\x3c\x4d\x37\xed\x4f\x07\x3a\xce\xdd\x93\x58\x23\x2a\x2c\x55\xfc\x4c\xbc\x9a\xca\x90\x3e\xe7\xef\xe0\x62\xd7\xd5\x4a\xca\xf4\x70\xf7\x8c\x18\x38\xcf\x1f\x02\x49\xa8\xf3\xec\x6f\xee\xae\x86\xfd\x57\x43\x4f\x22\xc7\x20\x5d\x80\xe2\xf4\x1e\x60\x14\x54\xd9\x1b\x6f\x2e\xe7\xf0\xa4\xc5\x3f\x12\x83\x83\x24\x83\xdb\x67\xfa\xc8\xb7\xc3\x08\xfa\x01\xb5\x32\xdd\xea\x0f\xa0\xb1\xef\x4e\x76\x95\xa8\xf0\x7e\xdb\xc3\xe1\x92\x98\x1c\xec\xda\x15\x35\x73\x47\xb0\xda\xf7\xbc\xb0\x74\x1b\xe3\xb8\xe0\x82\xf3\x88\x64\x04\xc6\x06\x2e\xac\x0f\x3e\x41\x2b\x70\xd8\x2a\x0c\x9b\x74\x09\x5c\x28\xa7\xd3\x73\x4a\x22\xdc\x02\xed\x10\x3e\xcb\x74\x29\x52\x19\xd5\x13\xc3\x31\x3f\xb3\x87\xc3\x76\x54\x39\x22\xde\x52\xec\xb8\xb0\x28\x7b\x29\xb2\xcc\xe3\x42\x62\x1d\x8b\xcc\xb7\xde\x38\xbc\x90\x68\x3d\xc5\x13\x2d\xc3\xac\x9b\xb9\x99\xd5\xf0\x8b\x40\xa7\x3c\xfc\x99\x5c\xea\xd3\x43\x18\xde\xdc\xec\x62\x5c\x53\x8a\x6b\x16\x2e\x01\x0f\x42\xec\xb8\xb2\x31\xb5\xf6\xfc\x2b\x1b\x4c\x5e\x66\xf0\x49\x73\x8e\x61\x93\x99\x1b\xd2\x41\xf0\xc9\x82\x3a\x8f\xac\xdd\x8e\x00\x34\x9c\x2e\xfa\xaa\xf1\xb0\x4b\x83\xf3\x26\x33\xc1\xef\x2e\xcf\xc2\x88\x8a\x5d\xf4\x1e\x35\xa0\x44\xc1\x5f\xd2\x9f\xce\xf5\x94\x8c\x8b\x4d\xfc\x03\xbf\x0b\xac\xae\xcd\x63\xcd\x01\xe6\xc5\x2e\x48\xb2\x47\x41\x2f\xef\xa0\x53\x7b\x62\xab\xaa\x6b\x7f\x6f\xe9\x78\x7b\xe9\x04\xb0\x3d\xd3\x9f\x1c\xc7\x64\x37\x96\x18\x67\x50\x95\x0c\x15\xf6\xec\xcb\x1d\x6d\x88\x6f\x61\x51\x81\x4e\x58\xc9\x4d\x2d\x20\xdd\x32\x8b\x11\x6f\x45\x76\x83\x07\xf4\x7a\xca\xea\x1c\x85\x4f\xf9\x5b\xa5\xb0\xbe\xbe\xb8\x8a\x5c\x67\xe1\xb7\xc7\x25\xf6\x63\xf2\xa0\x95\x3e\x4d\x2a\x57\xd6\x59\x9b\xe4\x17\x47\xbf\x43\xb8\x8d\x2a\x61\x1e\x97\x32\x11\x23\xec\xe9\x5c\x5a\x1d\x1c\xc2\x7b\x70\x02\x91\x7c\x56\xe9\x39\x00\x63\xe2\xb2\x41\x33\x66\x93\xf2\x1a\xb6\xf1\x42\x72\x48\xdc\x85\x06\xc2\x4f\x04\xac\x50\x55\xa7\x99\xcb\x0d\x2b\x4e\x1a\x33\x15\xfe\x9b\xef\x60\x14\xc7\xc7\xf8\xad\x57\xea\xba\xfe\xcb\xff\x9e\xf1\xb8\xfe\x5c\x32\x62\xfc\xfd\x5d\x46\x90\xc7\x09\x41\xb4\x6f\x45\x49\x6e\x40\xd3\xe7\x2d\x2b\xac\xda\xc8\x42\xdf\xbd\x4c\x4f\xa1\xb4\xb2\x73\x59\x3e\x4c\x06\xd0\x36\x40\x33\x09\x49\xc3\x3b\x40\xcb\x7d\x31\xc2\x38\x6e\xfb\x8a\x2c\x84\x2a\xd3\x4b\xf5\x4f\x5d\x1c\xa9\xc5\xe6\x51\x11\xfb\x4c\x41\x32\x51\xea\x00\x54\xff\xf1\xf6\xe6\x5d\xee\x2b\x5a\xd6\x59\x96\x65\x0e\x00\x3f\xbe\xb6\x99\x47\x5a\x00\x90\x1a\xb3\xf7\xdc\x5a\x27\x29\x9e\x4e\x49\x5b\x95\xe1\x90\x10\x38\x7f\xc0\x42\xa5\x24\x86\x8f\xe9\x03\xd4\x9c\x49\x96\x99\x07\x84\x1e\x0c\xf1\x5f\x4b\x19\x49\x0b\xe6\xdb\x9a\x16\xd7\x04\xeb\x36\x43\x8b\xd5\xc2\x9a\xcb\x6a\x6c\x27\x4c\x21\xc4\xf5\x58\xf2\x12\xe3\xe6\xd4\xe5\xf9\x83\x78\x77\xde\x53\x3a\xd3\xba\x3e\x34\xe5\x95\xd4\x6e\x91\x30\x26\x11\xa2\x17\xd4\xbd\xb2\xfe\xdd\xf2\x81\x01\x7e\xa9\x5d\x49\x07\x74\x55\x19\x53\x62\xa7\xfd\x9e\x56\x50\x2f\x03\x96\x4c\xbf\xdf\x9b\x69\x28\xd8\x82\x43\x2f\xb3\xe6\x8d\x4d\xad\xed\x88\xb6\xdb\xcc\xed\x2a\xe3\xcc\x8c\x22\x21\x7c\x66\xe4\x84\x34\xce\xa1\x25\x1e\x51\x7b\xef\xd4\xe3\x75\xcf\x46\x54\x4d\x9b\xcf\x42\x4f\x4f\x23\x25\xdc\xcd\xfe\xc0\x54\xfe\xf1\x41\xab\xcc\xc3\x09\xda\x8d\xea\xe8\x52\xf2\xf3\x23\x48\xdc\x7e\xbe\x2b\xf3\x13\x26\x58\xa1\xf4\x02\xe0\xed\xcd\x7d\xbf\xd9\xe6\x0a\x5f\x4c\x2a\x25\x8c\x81\x36\x63\x4c\x29\x77\xb5\xa1\xf4\x04\x1e\x65\xcb\x33\x28\x96\x24\xdc\xcd\xb5\x7a\x33\xf3\x8f\x07\x19\xc0\x1e\x73\xec\xe9\xf7\xfd\x32\x68\xf2\x10\x59\x28\x18\xf1\x51\x31\x03\x8e\xdf\x14\x0d\xe3\xba\x95\x7f\x1f\x81\xe7\x8b\xa4\x2e\x4b\x2a\x65\x07\xab\x4c\x70\xe0\x19\xe3\xd7\x06\x2f\xf7\xc8\x5a\x5b\xff\x01\x5e\x4f\xd5\x37\xed\x84\x36\x15\x3e\xcb\x92\x45\x49\x63\x4c\xcb\x0d\xbc\x29\x4a\x63\x52\xd2\xe2\x1a\x3a\xc8\x0e\x19\xbe\x6c\xae\xe1\xbb\x97\xb4\x74\xd8\x85\x35\x3d\x2e\x4f\x3f\x61\x40\xbf\x7a\xe9\xa8\xe2\x61\xcf\xde\x23\xef\x8c\x1a\xa7\x5d\x1d\x03\xe9\x1a\xd5\xf6\x61\x64\x69\xc2\x39\x7f\xb1\x99\x2e\x88\x46\x4a\xb1\x81\x73\x52\x91\xb9\x60\x81\xb1\xa5\x17\x30\x53\xc1\x7c\x24\x21\xb0\x8c\x16\xf7\x86\xf7\xca\x1d\x63\x97\xe3\x24\xf3\xbb\x1b\x63\x43\xbc\xa9\x3f\xc0\x9f\xc3\xdc\x9b\x35\xbd\xe3\x25\xfa\x95\x6d\x98\x61\x19\xf7\x01\x8d\xa0\x01\x12\xbf\xd9\xd6\x91\x5f\x99\x32\x73\x91\xf0\x6d\x0a\xad\x86\xbe\x03\x3c\x6b\x3a\x95\xfb\x61\x77\x45\x4d\x62\xb5\x14\xff\x38\x5d\x6c\x12\x58\xea\x5e\x71\x9f\x16\xc1\x5a\x0d\x69\x8a\xe1\x6a\x94\x2e\xc4\xc1\x5c\xfd\x1d\xe3\xcc\x31\xf7\xcf\xb5\x61\xc7\xa4\x63\x6a\x95\xda\xb9\xba\x86\xc7\xcd\xb1\x67\x57\xd5\x75\x9d\x62\xa4\x68\x1d\x9e\x6a\xd0\x08\x2b\xc0\xe5\xab\x89\x61\xd2\xd1\xf6\xda\xb7\x9b\xe6\x4a\x2a\xac\x41\xd6\x56\x6a\x81\xfe\x63\x31\x91\x8d\xcb\x9f\x0b\x13\xc9\xdf\xfb\x13\xc0\x6f\xf3\x07\x3e\x06\x7f\xc8\x45\xc5\x01\x74\xad\xf0\x7d\x1c\x32\xc6\x16\x8b\x46\xa5\xbc\xc8\x24\x3e\x77\x41\x45\x85\xe3\xa4\x8c\x4f\xc0\xbc\x41\xbe\x0d\x3a\xe7\xc9\x41\x7c\x1d\x70\x74\xb2\xed\xaa\x80\xd2\xce\x2f\xc5\x59\x53\x0d\xb1\x35\xba\xa2\x32\x87\x09\xeb\x0c\xca\x22\x45\xb2\x3a\x17\xf0\x92\x04\xdf\x12\x03\x0b\x62\x6a\xf5\xa4\xa9\xf9\x67\x52\xa9\x2a\xf3\xb6\x11\x5b\x32\x46\xd4\x13\xae\xaf\xd9\x77\x05\x82\xb7\xf1\xfc\xd4\xc3\xf9\x19\x4e\x24\xa5\xb4\xac\x30\x52\x22\xa7\x29\x3f\x84\xf9\xbd\xcf\xa8\x83\x76\x91\x1f\x91\xef\xb2\xf5\x11\xa0\xd6\x8b\xb2\x57\x8c\xe4\xfd\x8b\x96\xbf\x07\xe3\x06\x8d\x4d\xc5\x2c\xfb\xba\x88\xcb\xe7\x73\x17\x31\xd3\x2e\x31\xc9\x72\x5c\xd6\xb6\x54\xd4\x5a\x76\x5e\x07\x23\x09\x0d\xaf\xc6\x45\xa7\xb9\x3c\x11\xe5\x96\x44\xd1\x69\x7d\xad\xd9\xf5\x59\x4d\x5c\x54\x86\xc4\x83\x97\x19\x6a\xac\x7d\x4d\x11\x69\x08\xa0\x38\x8b\x59\x18\x8f\xd8\xab\xea\xaa\x7e\x21\xa8\xd5\xb8\x59\x2b\x67\x75\x93\x2c\xc4\x3a\x22\x1f\x85\xe9\xe7\xdf\x6d\xfb\x0a\x76\x47\x93\xd9\xde\x05\x6a\x97\x2a\xdf\x7c\xe9\x1c\x68\x63\xf5\xf3\x2a\x8d\x08\xe7\xd7\x5b\x46\x25\x9c\xd3\x27\xcd\xd9\x86\xc8\x8c\xcc\xa5\xa5\xe2\xe9\x09\x4e\xca\x55\x0d\xf2\x1b\x18\x2f\x6c\xa9\xe5\x1c\xbb\x4c\x85\x18\x54\xb1\xcf\x01\xb9\x4c\x7b\xd1\x49\xa5\xd8\x7b\x53\xdb\x0a\xf6\xe2\x72\xae\xa3\xf7\xee\xa8\x31\x4f\xee\xe7\x56\xd5\xd2\xb9\xd7\x0d\x07\xce\xa7\x24\x5b\x0d\x5a\x7f\xf3\x55\x24\xa2\x4c\x52\x1d\xb8\xd2\xbf\xdb\x04\x8b\xfd\x71\xef\x13\x62\x5a\x46\xd9\x8d\xfd\x82\xb5\x9b\x56\x68\x85\x95\xb1\xf3\x81\xeb\x28\xce\x56\xa3\x3c\xf2\x0f\xb3\x66\xd3\x91\x7f\x39\xe7\x42\x13\x49\x3f\x62\x48\xd0\xc0\x77\xf1\x31\xa3\x26\x70\x32\xe4\x3b\x7f\x28\x5a\x56\x16\x7a\x57\x5a\x4c\xca\x7a\xb6\x5e\x37\x0f\x8a\x9d\xc3\x1b\xf6\xdf\xa3\x07\xbe\x0d\x3b\xba\xdd\x68\x95\x60\xfe\xf0\x98\x5e\xd9\xad\x7d\xac\x69\xc4\xdb\x55\xdd\x9c\x0c\x0e\x61\x84\xaf\x04\x34\xf7\x0d\x77\x93\x6a\x0a\xca\x37\xa2\xe1\x5e\x06\x41\x74\x6f\x72\x47\x5f\xa5\xb5\x60\x47\x4f\x79\x70\xcc\xee\xa9\x01\x7a\xb7\x1a\x31\x18\x90\xea\x94\x07\xf8\x90\x4d\x06\x8a\x53\xea\x57\xf7\x66\x4b\x8d\x4f\x43\xa7\x03\x54\xf6\xf3\xd6\xff\xda\x1c\xec\x45\x8d\x31\x1d\xfd\x79\x61\xf5\xb7\xba\x54\xf0\x4b\xec\xcc\xf0\x1a\xb9\x83\x79\xb1\x01\xe0\x63\x7f\xcd\xc9\x4d\x5b\x72\xfb\xf9\x8f\x6e\xc8\x0c\x03\x68\x8e\xe7\xf9\xda\x86\xfa\xc5\x0e\xa9\xbf\xc3\x07\x4f\x53\x7b\xe4\x6d\xcc\x8c\x8f\x8c\x22\x77\x9b\x68\xd7\x5d\xce\x4c\xa4\xaa\x4c\x75\xde\xa0\xf9\x4d\xe0\xe7\xde\x30\x75\x50\x33\xfb\xcb\x50\x42\xaf\x6e\x3f\xa6\x69\x7f\xd7\xda\x70\x43\x6d\x5f\xf9\x23\xdd\xc8\x9f\xab\x71\x99\x3f\x7f\x1f\xcc\xf5\xbf\xed\x6f\x8d\xcb\x31\x99\xfa\x7a\x56\xd8\x54\x34\xd8\xb2\x39\x15\x2f\x1d\x1a\x25\x71\xfd\x84\xc1\xf1\x14\x92\xee\x68\xb7\x40\x7b\x02\x04\x1d\xa0\x80\xe6\x78\x21\xcd\x88\xd9\x0d\x96\x09\x3f\xd0\xe4\x10\x12\x72\xa8\x59\xec\xc5\x75\x09\x93\xd0\x37\x93\xd2\xf7\xe5\xbc\x82\x80\x8c\xf5\xa9\x07\xa7\x09\x2e\xb1\x07\x0a\x1d\x47\xd0\x2f\x0b\xbc\xf1\xd0\xfd\xb0\x2e\x6b\x41\xca\x78\x2a\x0b\xa7\x90\x70\x41\xb8\x4d\x61\x27\x3d\xc4\x0a\x98\xb4\x88\x14\x90\xf9\x1f\x36\x9c\x95\x43\xce\xbf\x84\x77\x8f\xdb\x6a\xfa\x50\xda\xc3\x6c\x4b\x80\xd2\xe0\xad\x67\x3f\xcf\x8c\x17\xf0\x11\xf2\x98\x0b\xb6\xd1\xa1\xb5\xe6\x2a\x3a\xbf\xab\x3c\x87\xe3\x70\xd7\x10\xf6\x6f\x09\x10\xbb\x95\x85\x9a\x79\x5b\x5c\x0d\x9e\x3a\x9f\xa4\x00\xe1\xd5\xef\x6e\xf0\x86\xc7\x54\x74\x2f\xa5\x12\x5b\xfa\x38\x5b\xee\xea\xbb\x98\x47\xea\xd3\xbe\x2a\xb2\x72\x02\xeb\xb3\xc9\xa4\xf7\x9b\x51\xbc\x81\x85\xa3\x6d\xb5\x1d\x5d\x7b\x9a\x16\x45\x61\xae\x66\x50\x5f\x60\x9a\xda\x5a\x46\x84\xc1\x96\x9a\x91\x0c\xdf\x7f\x6c\x95\x96\x76\x72\x91\x2a\xc4\xe3\x4f\x41\x2f\x0f\x9d\x92\xd5\x0d\x6c\xe1\x31\xd4\x6f\x16\x72\xa7\xd3\x15\x3c\x11\x8e\xd5\x77\x59\x6e\x35\x0e\x0a\xd1\x24\x3c\xa1\xf9\x98\x55\x94\xcb\x29\x28\x35\xd6\x3f\x2a\xdf\xa9\xf9\xed\xcc\x1f\x8c\x67\x55\x87\x57\x19\x1f\x2d\x10\x86\xf8\x91\x96\xf4\xe1\xb9\xcc\x8a\x1e\xf8\xb3\x77\x72\x5d\xec\x43\x34\x8b\xb7\x39\x44\x9e\x76\x42\xce\x16\x56\x5b\x71\x4b\x4e\xa3\xc8\x13\x0d\x32\x2d\x55\x6f\x4a\x76\x68\xc5\xba\xbb\x63\x56\xc4\x21\xa0\x67\xce\x26\x21\x08\xa8\x1c\xc1\xf3\xe2\x28\xef\x86\x3c\x32\xe0\x1a\x00\x76\x04\x5f\x30\xed\xfb\x86\xab\xfc\xb5\xbc\x63\xa6\x24\x23\x4a\x3f\x3e\xdb\x5c\xba\x5c\xb7\xee\xe1\xd7\x36\x97\xec\x83\x04\x63\x97\x93\xf4\x25\x35\x76\xe2\x56\xe8\x85\xba\xae\x2a\x83\x49\xa2\x2d\xb2\x99\x0e\x7a\x87\x4e\xb1\x8a\x89\x23\x8b\xda\x1e\x13\xd5\xeb\x0a\x7a\x2e\xcb\x2a\xa4\x9a\xe6\x69\xd2\x9c\xc5\x02\x85\xda\x5f\x07\xfd\xa1\x73\x80\x7c\xf9\x73\xd5\xd9\x4a\xf9\x7b\x3a\xed\x94\xc5\x43\xbc\x0f\x8e\x09\x1c\xd6\xeb\x12\x45\x80\x2d\x73\x42\x91\x0e\xc1\x3e\x34\xa4\x31\xd0\xa6\x9d\x9a\xaa\x40\xdf\xd5\x25\x5d\xb7\x07\x0a\x3a\x59\x82\x3e\xa8\x9b\x13\x33\xde\x79\x47\x86\x1c\x44\xb3\xbc\x58\x37\x72\x9f\xf9\x50\x96\xa6\xfc\xd1\x94\x88\xe9\x29\x50\x12\x06\x30\xbe\x22\x84\x92\x1c\x38\x59\x96\x60\x46\x11\x08\xf2\x8a\xf4\x5d\xeb\x99\xf6\x83\xc1\xea\x03\xd2\x2f\x9b\x68\x2b\x86\x8d\xed\x20\x92\x6a\xfd\x28\x45\xdf\xe2\x04\x50\x50\xb0\x84\x17\x53\xe8\xda\xbc\x75\xae\x68\xa8\x17\x4c\xfc\xa4\x79\x8a\x7a\x78\xc6\x5d\x32\xc0\x7b\xd0\xeb\x98\x4d\x07\x1f\x91\x46\x75\xed\x2d\x4d\xd7\x4a\xc8\xae\x7f\x08\x0e\x38\x57\xd6\x47\xe8\xf1\xfd\xbd\x72\xdc\x7e\x0c\x82\xd3\x03\xeb\xf6\x77\xd5\x85\x9c\x83\x9e\x27\x0a\xbd\xfa\x00\xee\x40\x74\x77\x65\xe8\x35\xb6\x8d\x26\xb8\x6d\xb8\x93\xdb\xc7\x6f\x9f\x73\x51\xba\x5b\xe8\x30\x56\x97\x99\x78\xae\x40\xad\xa4\xc7\x31\xbc\x60\x65\x06\x96\x99\x2b\x5b\x0f\x2c\xcb\x3e\x2a\xe4\x5d\x57\xf2\xca\x01\xca\xca\x4f\x56\x2f\x2c\x80\xd6\x23\x68\xf9\xa3\xc0\xca\x3c\xd9\x2a\xd6\xab\xf3\x60\x49\x6a\xf3\x44\x75\xa8\x74\xbd\x52\xac\x75\xaa\x7b\x3b\xac\xcb\xfb\x75\x45\x01\x3f\x6c\x14\xb2\x87\xb4\x5d\x9c\x4d\x14\xfd\x53\x28\x77\x60\xd8\x3b\x42\x2a\x85\xd3\x44\xd4\x8a\x88\xb7\xcf\xef\x7e\xb4\x47\xe5\x58\xf8\x26\x4c\x89\xfa\x57\x5c\xc6\xe0\xde\xdd\x5d\x0e\x65\xf6\x11\x07\x1d\x69\xf3\xd0\x40\x0b\x28\x3c\x25\x55\xf1\x9b\x0a\x87\x9c\x20\xf2\xb5\xda\x3d\x95\xd1\x95\x75\x04\x0d\x9c\x97\x83\x4d\x69\x9c\x02\x45\x81\x92\xc8\xef\x43\xae\x46\xf7\x3b\xa7\x5f\x68\x70\xc5\xc0\x6e\x38\xc0\xcd\x4a\xbd\x31\x5f\x21\x43\x1e\xb5\xc5\x26\xfe\xd6\xf0\xb7\x7f\xfa\x90\xaa\x3a\xc2\x5d\x98\xc9\x7c\xd9\xf9\x26\xe7\x37\xfe\x98\x1f\xee\xa3\xc6\xf7\xc1\x15\x92\x0b\xe6\x03\x89\xeb\x0f\x16\xa8\xfc\x3b\x16\xfe\x99\xf2\x7d\x8d\xe7\x54\x5a\x5c\x59\x3d\x1e\xe8\x53\x8a\x40\x16\x16\xc9\xc6\x97\x17\xa6\xc6\xd3\xe8\x7f\xa7\x67\x90\x30\x35\x83\xb8\x2b\xf1\x53\x43\x42\x92\x90\xf2\xb8\xd1\x8d\xda\x14\x3e\xbe\xf2\xfe\xb4\xd7\x1b\x0e\x06\xe9\x49\x86\xa9\x99\x92\x2f\x6d\xaf\x0d\x9d\xbd\xff\x83\xa5\x6e\xbe\xef\x7f\xaa\x14\xec\xff\xc1\x11\xf7\xc7\xe5\x0f\xbc\x0d\x9e\x18\x37\xb3\xda\x00\x3a\xb4\xaa\xaa\xfe\x15\x8e\xf2\xd3\xc5\xd3\x61\x1f\xf9\x89\x68\xd7\xdf\x76\x4d\x22\xed\xf8\xe1\xf9\x2c\xb0\xb0\xb5\xcf\x1d\x9f\xea\x6a\x72\xb0\xab\x90\x7a\x85\x38\x76\x99\x0b\xb1\x22\xc2\xbc\xc0\x55\xb6\x88\x69\x32\xae\x18\xb9\x3e\x71\x7e\xc6\x9b\x10\xe4\x87\x7c\x8e\x80\x5f\x0e\x1e\x5f\xd1\xf7\x59\x9b\xee\xb3\x6f\x85\x93\x19\x43\x7d\x26\x10\x54\x8b\x63\x4e\x58\xd3\x9b\x45\x65\x59\x11\x08\x0f\x12\x38\x54\xad\xd6\x16\xdf\x11\x61\xa3\x01\x77\x9a\x28\x42\x9b\xaa\xf1\x86\xcc\x93\x43\x1b\x2e\xc5\x77\x5b\x84\x74\xad\xca\x7a\x76\xe3\x75\x16\x82\x8f\x66\x42\x4c\x86\xfd\x4f\x48\x76\x93\x39\xd4\x65\x29\xc8\x98\xe5\x8c\x93\x20\xd8\xa4\xbc\x0a\xa4\xae\x86\xca\xf3\x85\xdc\x6f\x2c\xa8\xb4\xb4\x36\x6b\x65\x87\xda\x3a\x97\x59\xea\x9b\xae\x4a\xb4\x08\xf2\x00\x2f\x9a\xa3\x5c\x50\x4b\xc2\xc6\xfd\x1d\xc4\x58\xdb\xbe\xf2\xcd\xf8\x2d\xf7\x48\x4c\x88\x5b\x09\x64\x5f\x8b\xae\x08\xb4\x36\x33\x16\xbe\xf4\xe6\xdb\x5b\xa7\xb1\x9a\x85\xc5\x4b\xdb\xd7\x01\x9e\xfe\x2d\xca\x27\x6b\xfc\xd4\x39\xee\xa9\xec\xdd\x49\xe8\xca\xba\xfb\xac\xeb\x94\x2d\xce\x2d\xc8\x1b\xad\x79\x21\x0e\x52\x02\x6e\x9a\x95\x7e\x76\x28\xb2\x13\x09\xe0\x71\x88\x2e\x74\xcf\x87\x90\xdb\x7d\xfe\x97\x4e\xe1\xc0\xa6\xa0\x56\xe7\x0e\x34\x18\xd5\x7c\x79\x7c\x8b\x0f\xb9\xdc\x7f\xe5\x3e\xe9\xa0\x43\x3a\x83\x01\xc9\x86\xb8\x20\x0d\xca\x49\x33\xb7\xf3\x58\xec\x5c\xf6\xdb\xaa\xad\xe3\xea\x5f\xdb\x3b\xb4\xe9\xc2\xe1\xbc\xce\x49\x78\xa2\x3f\x95\x70\xee\x6f\x30\x4d\x3a\xe0\x74\x5d\x97\x1a\x59\xbc\x84\xc1\x79\x14\x61\x53\xe3\x10\x2a\x17\x48\x8e\x6b\x16\x71\xb9\x06\xcd\x7e\x83\xa7\x74\x46\xc5\x1b\xfb\x96\x7e\x26\xad\xd3\x37\x4e\x42\xa3\x75\x86\x00\x39\x08\xd3\xfc\xb3\xd0\x88\x6b\x6b\xa7\x31\xdb\xdb\xa6\x5f\x45\x25\xbc\x6c\x37\x5c\xd0\x4a\x69\xa2\x6e\x69\x99\x6e\xe2\x0f\x7e\x9d\x9a\x91\xab\x3d\xa0\xc9\x5b\x2e\x0f\x4b\xc4\x05\x7a\x6d\x0a\x63\x63\xb1\x13\xaa\x00\xcf\x7f\xa5\xfa\xd5\x3d\x8e\xf3\x66\xfe\x00\xab\xc3\xde\xf9\x2b\x44\x79\x4b\xc4\xcc\x24\xdf\xae\x1b\x1a\x87\x76\x4c\x37\x2f\xea\xad\x6a\x89\xac\xdc\x18\xec\x59\x3c\x3a\x9a\xad\x97\xed\xb5\xa3\xdd\x32\x0e\x09\x9c\x2e\x27\x5a\x19\x65\x99\x55\x49\xff\x44\xa3\x37\x18\xc8\x2c\x86\x9d\xd0\x8c\x97\x8e\xd5\xc5\x5f\x7f\xc5\xf1\x6b\xcf\x8b\x21\x2a\x87\x5b\xa8\x7e\xa3\xb8\xdf\x63\x0a\x77\xbf\xcc\xfd\x1e\x9d\xfb\x18\xa5\x49\x28\x4c\x50\x3e\x07\x24\xb5\x81\x19\x0e\xd2\xf5\x4d\xf7\x3e\x6f\xa4\x76\xea\x3c\xfb\xfd\x87\x56\xdf\x22\x3d\xfe\x54\xa9\x5f\x05\xff\x59\x7d\x75\x1f\xfa\x59\xfc\x8f\xf7\xad\x12\x34\x52\xe8\x5c\x8e\x71\xa0\xdd\x1a\xd1\xe7\x36\xa9\x59\x1a\x69\x6c\xd2\x92\xe8\x2e\x5b\xef\xdd\xa5\x58\x04\x60\x2d\x32\xfc\x85\x20\xc0\xb8\x4e\xf9\xc6\xbe\x75\xcb\xa8\x4d\x07\x3d\x5d\xfb\x7c\x2d\x67\x81\x5c\xff\x84\x24\x83\x97\x01\xcb\x90\xef\x82\x73\x89\xe9\xf6\xd4\xf3\xcc\x14\x28\x29\x92\x32\xab\x2a\x17\x4b\x15\xd7\x1a\xaf\xbc\x84\x0b\x30\x95\x39\x91\x2c\xc9\xac\xb6\x0f\xdc\x07\x12\x57\x97\xb0\x6a\x9e\x49\x2b\x89\x21\xd2\x7e\xe0\x6c\x80\xba\x9b\xac\xf3\x64\x46\x3e\xd8\x43\x34\x8d\x0f\x95\xd1\xf0\x82\xbc\x0d\xf4\x6e\xc1\x96\xfe\x5a\xc7\xf6\xa3\xf7\x5c\x5b\xde\x1a\x5b\xb2\x43\x96\xf8\xad\x59\xcb\x0f\x05\xd2\x7b\xcc\x51\x6c\x92\x49\x81\xbf\x6e\x23\x6d\xed\x93\x91\x56\x2f\x77\x1f\xbd\x53\x9a\x31\x82\x40\x73\x5f\x7e\xcf\x46\x12\xa4\xf0\x84\xfc\x77\xeb\xed\xf4\xd0\x1f\x4f\xa3\x8f\x20\x2f\x93\xd9\x95\x85\xe4\xa9\x4b\x9c\x3d\x21\xea\xc3\xac\x85\x76\xe4\x19\x3e\xa3\xaf\xee\x75\xa3\xb3\xb5\x20\xc3\xa3\x50\x52\x76\x2d\x25\x1d\xc4\xa4\xe8\xdb\x08\x02\xa0\x5e\xa2\xe2\xcd\xb2\xa3\x9d\x16\x0b\x96\xd5\xd4\x71\x38\x00\xe3\x37\xf3\xd3\x56\xf0\xa9\x33\x97\x65\x22\xb5\x0c\x15\x11\x34\xbd\xa2\x7f\xc9\x3c\xf4\x0a\x0f\x61\x29\x67\x0c\x5d\xb1\x87\x23\x56\x1b\xc2\x19\x7d\x3c\x23\xab\x0c\x6c\x6d\x08\x6b\x89\x74\x02\x16\xbb\xa4\x94\x0e\xa8\x5e\x56\xca\xce\x46\x09\xbd\x1b\x31\x03\x8c\xc5\x07\xb7\x92\xb3\x89\x26\x0f\x83\x20\x7a\xae\xc8\x94\x9e\x8f\xb5\xe7\xc5\xe6\xd5\x48\xe5\x33\x0d\x9f\x7f\x89\x9c\xbf\x80\xc6\x62\x35\x0e\x73\x31\xfc\xed\x52\xc9\x42\x15\x8d\x7e\x53\x21\x6f\x92\xd9\x5d\x35\x1c\x65\xb4\xed\xb8\xd5\x7e\xbe\x54\xf4\xb0\xf0\xfa\xb5\xa0\x84\x31\x38\x88\x93\x21\x44\xef\x62\x1f\x42\xea\xab\x58\x8c\x96\x71\x26\x54\xd5\x88\x12\x81\xac\xaf\x93\xbf\x16\xca\x38\x3c\x54\x4b\xbc\xa3\x56\xd3\x52\x10\x5e\xcf\x05\xe8\x70\x8d\x5d\xa0\xf1\x1a\x4f\x87\x35\x04\x82\x23\x61\x7c\x8d\x20\x83\xa3\x07\xcc\x75\x2a\x09\x9f\xda\x76\x6c\x35\x6d\xb6\x73\x9b\x52\x11\x98\x52\x90\x05\xb3\x0a\xce\xce\xf5\xe3\x13\xd9\xe4\x1c\x3d\xd7\x27\xbc\x08\x3c\xa7\xe9\x9b\xbd\xb3\xcb\xc9\x10\xb7\x8e\x1f\xfb\x8f\xad\xc0\xc5\x58\xff\xa9\xd2\x70\xa2\xfe\x71\xb4\xbd\xfd\xcf\x34\xa4\x86\xbe\x47\x89\x37\xf4\xdc\x83\x1d\x0f\xa3\x11\xdc\xf0\x99\x77\x98\x8f\x82\xc6\xdd\x9d\x3c\xdd\xcf\x27\x0e\x20\x2c\x20\xed\x0a\xe5\x6a\x0e\xa4\x2f\x56\xc5\xf8\xe0\x37\x0b\x32\xd1\xfa\xcc\x3a\xb2\x46\xc1\x5d\xcb\xb2\xc2\x63\xe8\xba\x1f\xff\xbd\xc8\x65\x99\x8b\x20\xac\xc0\xc9\x19\x95\x03\x22\xd3\x74\x9d\x65\x54\xc6\x7e\xbd\x31\xa1\xf4\x03\x29\xd0\xe0\x89\x1e\x63\x54\x67\x3a\x9d\xbc\x12\xe0\xb5\x98\x46\x65\xa5\xb8\x52\xa0\x0e\x1b\x80\xdb\xfd\xd4\xf7\x27\x12\x43\xa9\x01\xd3\xdf\xc8\x07\xbb\xa5\xb8\x32\x56\xb9\x3e\x62\x5a\x7c\x07\x53\x3f\x59\x1e\x0c\x94\x72\xa2\x0f\x52\xd7\x8f\xb7\x3b\xb9\x4c\x5c\x50\xc3\x62\x10\xb9\x2d\xb1\xe1\x1e\x59\x07\x5b\x90\x26\xaa\x24\xac\x03\x11\x3a\x30\x3e\x15\xa1\xc4\x4f\x21\x45\xd4\xc9\xfa\xb2\xb6\x64\xd4\x0e\x8c\xb4\xe3\xfb\xa2\x7e\x63\x45\xaf\xac\xcc\x43\x3b\xbd\xd6\xe7\xc8\x08\xb2\x27\xda\xdf\xe2\xc7\xcd\x29\x40\x6a\xe5\xa4\xc4\x9d\x72\x6f\x14\x45\xf3\xb0\x04\xdb\xde\x80\xd0\x51\xbb\x1a\xb7\x61\x32\x70\xfb\xc9\xfc\xf3\x25\xd6\xed\xe9\xaa\xcd\xad\x2f\xc6\xbb\x53\x70\xc7\xcc\xb1\x36\x16\x4c\xbf\x6e\x05\xaa\x3e\x37\x21\xa8\xa6\xd7\xd9\x27\x18\x88\xf7\xd4\xbe\x0a\xb3\x93\xf5\x3a\x2f\x2e\x57\x6c\xe6\x5d\x3a\x3d\xcb\x27\xf7\xdc\x3c\x02\x12\x9a\x0d\x85\x11\x8a\x6d\x57\x4b\xd4\x46\x2a\x36\x9c\x00\xc0\x3b\x84\x4a\xa8\xa8\xbb\x78\x46\x76\x96\x8f\xa2\x37\x8b\x0f\x86\x0b\x5c\x49\x5b\xe0\x72\x47\xe4\x65\x97\x35\x17\x46\x73\x14\x1e\x7a\xa6\xc6\xb9\xcf\xe9\x6a\xe7\x63\xb9\x04\x7c\x36\x48\x34\x1c\xe5\xbe\xe3\x36\xac\xbf\x03\x68\x62\x3d\xbd\x87\xf2\x84\x02\xe4\xce\x7a\x0f\xe8\xfd\x76\x33\x73\x42\x16\x15\xfa\xc3\x49\x07\xb4\xd3\xfe\xc7\xd0\xc3\x83\x34\x2b\xed\x5a\x22\xa3\x38\xd1\x12\x99\x17\x46\x16\xfd\x87\x94\x74\x6d\xcf\xe6\x88\x36\x6f\x87\x11\x46\x9d\x8c\x90\x2e\x5d\x0b\x33\xaa\xb8\x5d\xf8\x45\x0d\x72\x74\x4d\xe5\x4e\xdf\xb4\x39\xe3\x72\xa9\xaa\x14\xe5\xfc\xcb\x8a\x67\x74\x60\xee\x08\x39\xce\x7f\x06\xec\x27\x25\x80\x2d\x79\xef\xce\x21\x51\x61\x9b\x14\x26\x56\x17\x84\xa7\xa5\x98\xd3\x05\xb3\xc5\x08\xdb\xb4\xe4\x70\x9b\x08\x81\x93\x76\x18\x11\x0a\xb6\xfe\xa2\xf0\x0d\xdc\xa7\x4e\xbb\xd6\x8c\xb4\x97\x11\xe1\xe6\x3b\x37\x47\x0d\xa8\x61\x3c\x08\xd9\x35\xfa\xbe\x9b\x71\xa9\x31\xde\x6e\x56\x01\xb8\x8e\x9c\x5d\xe5\x31\x22\x91\x79\x78\x3e\x7e\x50\xf2\xab\x3e\xc8\x2f\x51\x9a\x09\x6e\xc4\xd0\xbb\x29\xfc\xa1\x9b\x3c\x35\x64\xe7\xc5\xef\x3d\x7b\x35\xc2\x9b\xc2\x62\xea\xe8\x18\x19\x95\x44\x59\xb6\x5f\x89\xc3\x46\xdf\x8c\xb9\x23\x32\x39\x74\xd9\x71\xea\x61\xe3\x84\x9f\x2c\x5b\x5b\x3f\x01\x62\x1e\xe7\xb5\x1c\xf2\xf3\x9d\x25\x00\xb4\x32\x08\x82\x82\xa8\xac\xd3\x1c\xef\x76\x6b\x36\x49\x99\x04\xfd\xc1\x23\xad\x62\xfe\x73\xb5\xa4\x96\xe5\xef\xf8\x20\x28\x4b\xe0\xff\xe6\xa1\x11\xea\x4a\x4e\x82\xa8\x09\x6e\xee\x73\x0b\x42\x19\xc6\xf5\xc7\x96\x57\x59\x97\x7d\x76\x82\x6f\x21\x48\xa1\x63\x13\x36\x06\x4f\x7d\xf5\x2d\x02\x58\xa5\x49\xc5\x7b\x5e\x5c\x1b\x2a\xf4\x43\xe0\xf7\x8c\x73\x98\xba\x4d\x78\x5b\x16\x50\x59\xca\x6b\x00\x3e\xe0\x84\x2c\x13\xcc\xe6\x86\x49\xff\x8d\x09\x05\x90\x14\x81\x5c\x55\x49\x1a\xbc\xaf\xd0\x5b\xe5\x1a\xcd\x67\x89\x50\x20\x57\xa5\xdc\x72\x8e\xcb\xf5\xf7\x2f\x0f\x83\x03\x31\xc8\xad\x11\x71\xb7\x70\x4d\x58\xbc\x26\xb2\xa8\xce\xb3\x5c\x93\xfb\x34\x92\xb5\x47\x94\xa7\x26\x5a\x23\x97\x2b\x26\xab\x23\x0e\x4f\x58\xf2\xc4\xd6\xaa\xfa\x22\xb2\x9c\xe3\xf2\xe5\x1e\x96\x20\xce\xb7\x56\x9b\x7c\x3e\xe7\xab\x0e\x7c\xbb\xfb\x49\x68\xcc\xc0\xf3\x65\x9c\x1c\x05\x1c\x9e\xe7\x43\x9f\x1e\x30\xa3\x08\x02\x2c\x49\xcb\x71\x43\x0a\x08\xfe\xe3\x34\xf0\xe5\x31\x69\xa2\x39\x35\x1e\x82\xa2\xc6\x75\x8e\x1e\x43\x22\x3f\x3f\x2c\x14\xcf\x1b\xb0\xf6\x90\x8b\x45\xfa\xca\x34\x92\x67\x05\xff\x40\x55\x02\xa4\xa5\x02\x94\xa9\x9c\x60\xb4\xf4\x69\x27\x0e\xd6\x0a\x2c\x99\x89\x9a\x20\x1d\xed\x74\x9a\x81\x71\xe1\x7c\x09\x33\xb1\x72\x8f\xaa\xa9\x6e\x96\x5f\x54\x68\xf2\x3b\x36\x0b\x4f\x71\xd7\xf2\xd6\x35\x79\xcd\x6a\xfa\x15\x8c\xeb\x22\x46\x06\x5c\xda\xb5\xca\xc9\xb5\xb8\x02\x16\xc9\xc8\x24\x48\x69\x6b\xde\xea\x35\xfa\xd5\xf7\x96\x57\x08\x63\x5b\xed\x4f\xff\xb5\xc4\xfd\x36\xb3\x9e\xac\x66\x73\xd9\x3b\x9e\x40\xf3\x15\xd5\x05\xad\xd0\xac\x33\x9f\x03\x5f\x63\x92\x79\x6f\xe6\x36\xab\x3d\xf4\x99\x31\xcc\x70\x47\xb0\x78\x02\xc4\xfa\x78\xaf\xf5\xb6\x12\xa5\x00\x63\xf0\xb3\x08\x0d\xba\xbb\x33\x8c\x6a\x47\xa1\x61\xf7\xc7\x38\x8b\x79\x1a\x97\x6e\x6a\xb3\x72\x10\x9a\x97\x1f\xdb\x74\x1b\x26\x82\x7d\xf4\xd8\xe8\xea\xb3\xfb\xf1\xb2\x76\x30\x9b\x57\xf1\xf9\xd5\xb2\x58\x76\x07\xb7\x3d\xce\x0d\x85\xdf\x34\xd4\xe6\x58\xc1\x60\xc4\x54\x97\x73\xea\xc9\x16\x5b\x64\x08\xfa\x71\xb2\x17\x1b\x9a\x69\xca\x65\xe0\xee\x21\x50\xd8\x2c\x40\x00\x86\x1b\x3e\x78\xa7\xa0\x47\x0c\x6e\xa1\x11\x10\x56\x95\x8b\x17\x74\x30\xb3\xe5\xe9\x84\x8e\x96\xaa\x12\xd4\x0f\x2c\x78\x3c\x75\xa2\xb6\xe5\xe2\x0f\xd0\x4b\x5f\x75\x83\xa3\x49\x77\xe9\x16\xc2\x8d\x22\x22\xcd\x4b\x7e\x72\x5e\xde\xe5\x19\x03\x96\x73\x38\xbc\x5e\x7c\x59\xf7\xe5\x05\x16\x32\xab\xc5\xe0\x4f\xe9\x88\xbe\x2e\x3a\x9f\xd4\x85\x97\x3e\x3e\x36\x71\xb4\xa6\xf0\x53\x18\x03\x17\x5a\xaf\xc0\xdd\x97\x72\x4e\x21\x93\x96\x88\xd0\x75\x7d\x35\x39\x88\x24\xe5\x16\x98\x17\xcc\xf4\x69\x93\xe8\xde\xd2\x11\x2b\xe6\xde\x04\x92\xad\xc9\x31\x3a\x39\x0d\x9d\x4a\x3d\xfa\x6a\xe1\x6e\xee\xe4\x03\x9a\x8a\x48\xa9\x02\x7b\x4f\x24\xc1\x39\xcf\xea\x02\x5b\x8e\xa9\x9e\x28\x37\x93\x88\x71\x44\xbb\x72\x92\xdf\xf8\xf2\x5d\x71\x25\xd5\xf1\xb2\xea\xd2\x16\xbd\xfe\x8a\x18\x46\x86\x38\xde\x5a\x2d\xb5\x6f\xff\x70\xc4\x1c\xcf\x9f\x8a\x31\x53\xf1\xff\x97\x28\x9e\xf5\x29\x3d\xf4\x02\x61\xa3\xbb\x47\x08\xaf\x45\x10\x3e\x7e\xc0\xdb\xbe\x00\xc9\x00\xca\x6b\x76\xcb\x12\xc3\x87\x1a\xd4\x07\x79\x40\x23\x52\xf7\x56\x24\xaa\x5f\x6b\xeb\x39\x34\x5b\xe6\xa6\xf5\x8f\x55\x17\x0f\xaa\x09\x67\x89\xbb\x35\x19\xab\x6a\x28\x31\x83\x57\x0b\x5d\x1a\xbe\xea\xba\xa2\xcb\xb2\xaa\x2a\x37\xd1\xd4\xe7\xa7\x99\xaa\x90\xe0\x40\x0b\x6f\x01\x98\xc8\x2c\x81\x8a\x81\x4e\xd0\xc8\x82\xe5\x22\x1a\x92\x32\xfc\x5f\xf7\xf3\x58\x9d\x94\x08\xe0\x89\xa9\x5b\xb9\x2d\x29\xd1\x33\xb3\x73\xd2\x42\xa3\x2f\x1e\x84\x6b\x6f\x56\xbc\xd6\xb3\x1e\x92\xea\x01\x73\x08\x0a\x50\xf3\x00\xc8\xb3\x64\x6b\x31\x41\xf7\x7b\xed\x1e\x85\x1e\x56\x7f\x18\x37\xa1\x12\x84\x9d\xe9\x07\xe3\xcc\xae\x94\x3c\xc2\xcd\x78\x28\x72\x97\xef\x4e\x49\x33\x64\xa8\x4e\x36\x78\x6d\x1e\xec\x9a\xa4\x1d\x88\xaf\x7d\x75\xfa\x59\xf2\x20\x87\x4b\xef\x1f\x68\x6e\x19\x4f\xef\x99\xfe\x0f\x3e\xb6\x9d\x5c\x28\xcc\x69\xe9\x68\x59\xd3\xef\x58\xe7\x93\x5c\x71\x57\xb5\x15\x65\x4c\xdc\x55\xbc\xf7\xb9\x10\x76\x59\xe9\x7f\x7d\xfe\x6a\xf1\x45\xc8\x65\x5a\xe5\xda\x83\x4a\xbe\xd1\x0b\x02\xda\x09\x1e\xff\xe8\x09\xc4\x50\xdc\x56\x71\xa8\xe4\xf3\xe7\x1e\x37\xe1\x8e\x8a\x16\xaf\xd4\xd8\x3d\xbc\xe0\xc1\xc4\x8e\x6c\x96\x5c\xb3\xf0\xf7\xe0\x22\xe8\x93\xbf\x69\x57\xd8\x1b\xe2\xdf\xa6\x07\xeb\x83\x62\xf2\x8c\x73\x8a\x86\x14\x2e\x14\x6d\x3b\x41\xc4\x55\x76\x2b\x04\xa0\x8f\x89\x8c\xdb\xda\xd8\x82\x4f\x35\xc3\xa7\xd8\x87\x54\xad\xdc\xb0\x78\x8d\xcb\x3a\xc7\xdc\x66\x31\x4b\x56\x1f\x4f\x92\x15\xbc\x8d\x01\x1d\x02\xc1\xa3\xb6\xbb\x6c\x14\xca\xf2\xa6\xca\x6b\x55\xb5\x02\x2f\xc5\xac\x00\xc7\x2a\xc4\x16\x32\xb3\x6d\x33\x41\x66\x39\xb0\x89\x8b\xa8\x39\xec\x1a\xed\x2a\xfa\xc1\x26\x95\xbd\x8e\x90\x61\x61\x72\x10\x4e\xe9\x58\xd0\xbd\xff\x64\xef\x29\xc7\x07\x47\xdc\x61\x59\x67\x50\x4c\x7f\x74\xa0\xf7\xbd\x8c\x1b\xb7\xa5\x53\x0f\x7f\x4b\xc3\xfc\x72\x22\x3d\xf6\x04\xad\xba\xd4\x46\xbb\x90\xa0\x9a\xc5\x59\x67\x71\x49\x4b\xd6\x49\x98\x16\xaf\x03\x7a\x4c\xac\x48\x23\xab\xab\x27\xd8\xd2\xc8\x22\x51\x6e\x1a\x39\x58\x3d\x45\xa5\x73\x5b\x0f\x96\x37\x58\x16\xdf\xdb\x5c\x97\x37\x32\x74\x51\xcc\x79\xe0\xac\x12\x22\x6c\x69\x93\x9e\x18\xbe\x2e\x09\xd7\xcc\x04\x60\x4d\x5e\x1d\x55\x55\x0b\xd6\x99\x14\x8f\x1a\x7f\x59\xae\x6c\x33\x0b\xa6\xf8\x38\xbc\xc7\xdf\x0f\x11\x71\x88\xfa\x54\x26\xba\x66\x53\x2f\xe2\x09\xfe\xea\x91\x88\x6a\x58\x0f\x74\x0d\x44\xf9\x13\x39\xad\xfa\x69\x7a\xb8\x8e\x46\x63\x20\x2f\xb0\x85\x97\x3c\xf2\x2c\xf2\x50\x0b\x8f\xcf\xb3\x50\x4b\x56\xce\x8e\xee\x13\x1c\xf0\xa5\xba\x33\x7e\x72\xc5\xdd\xa3\x84\x90\xa6\xd1\xb1\x90\x2e\x18\xa4\x62\x05\xfd\x63\x9b\x0b\xf7\x9f\xcb\xd5\xcc\xc2\x3f\x20\xe3\xb0\x78\x98\xf7\xad\xca\xac\x21\x08\x6f\x38\x74\xb3\x1b\x32\xac\x33\xd6\xbd\x7b\xb5\xce\x04\x78\xbe\xcf\x2e\x65\x5b\x7b\x8f\x9e\x25\x02\x38\x5c\x1f\xb3\x23\xe2\x77\x89\xd5\x46\x99\xce\x78\xdc\xd0\x66\x32\x1e\x44\xf9\x71\x78\x79\x6f\xe4\x35\x18\x80\xd1\xc6\x3b\x12\xfc\x84\x80\xcd\x50\xff\x38\x93\x33\x25\x28\x0c\x23\x88\x6d\x40\x04\x96\xe7\x31\x66\x20\xa8\xcb\x2a\x30\x4d\x8a\x5b\xd3\x22\x72\xe9\x47\xfb\x61\x4b\x62\xef\x31\x5e\x43\xba\xff\x32\x85\xe2\xb1\xed\x65\xa6\x43\x42\x98\xe5\xb4\xc0\x88\x6a\x89\xf9\xea\x87\xf3\x6c\x79\xd2\xa0\x5c\xae\x5c\x52\x6d\x61\x73\x87\x65\xd7\x14\x0c\x38\x36\xd5\x4f\xb9\x73\x43\x0b\xc6\xfc\x65\xc0\x27\xc0\xe6\x66\xf6\xc3\xe3\x86\x50\xd5\xaf\x41\x76\x19\xd6\x4e\xbf\x1d\xad\xc3\x71\xde\x74\x9d\x8b\x0e\xd2\xb9\x61\x8e\x5b\xd9\x73\xbd\x16\x18\x25\x98\x0a\x4f\x88\xf6\x2b\x8a\xdd\x13\x4b\x99\x43\x2c\xff\x94\x01\x25\xb5\x91\xcd\xb1\x5e\x56\x67\x8c\x1e\x70\x82\xa1\x6a\x5f\x8c\x9f\xed\x9c\x00\xcc\x98\xf4\x41\x48\x00\x51\x6d\x6d\x9a\xeb\xe0\x94\xa0\xd7\x73\x2f\x35\xf9\xea\xf4\x0b\x53\xf5\xd4\x65\x4e\x74\x0f\x83\x76\x03\x90\x96\x0c\xe4\x40\x8d\xdd\xec\x85\x7c\xaf\x10\x7c\x32\x99\x4e\x92\x8e\x19\xc9\xae\x03\x53\xe1\x0d\xec\x34\xa3\x16\xf5\xf7\x22\xbd\x6f\x1f\x12\xdc\x0a\xf7\x52\x77\x7e\x6f\x9c\x73\xae\xb3\xb7\xfa\x5a\x0c\x17\x4e\x7d\x51\x81\x4c\x91\x4e\x1e\xd9\x6d\x15\x38\x61\xc2\xb7\x46\xb5\x1c\x34\x10\xa7\xe6\x32\x3d\x3a\x46\x42\x2d\xef\xda\x2a\xb7\xe9\x7d\x75\xaa\xc6\xcf\x41\x71\xfd\xe9\xaa\x91\x31\x0d\x35\xc9\xb4\xce\x75\xfc\xb2\xcc\xf9\xb3\x53\x12\xab\xf7\x47\x25\x7a\xec\x6d\x81\xb3\xc9\xf4\xbe\x6a\xf4\xe0\x2a\x20\x0b\x17\xb3\xb8\x7a\xf4\xa4\x53\x85\xdf\x9b\xa6\xb3\xba\xad\x05\x97\x32\xdc\xfd\xa6\x64\xf8\x1b\x21\x90\xb5\x58\x07\xe9\x85\x97\x60\xf3\x69\x0c\x6d\xc7\x57\xd6\xdc\x51\x04\x5f\x3d\xbc\xc9\x62\x4b\x87\xf8\x69\xf7\x5c\xc6\x02\x05\xb3\xf1\x1b\x4c\xac\x90\x2c\xac\xb7\x39\x07\x7b\x61\xc7\x0c\xbb\x07\xe9\x9a\x9b\xfa\xb4\xd6\xca\xf3\x34\x5a\xf5\xb1\x07\x8c\x32\xb4\x15\x73\xe9\xb7\xd2\x2f\x4a\x82\xd3\xb6\x96\x5d\x56\xd7\x1b\xb6\xc7\xaa\xad\xbc\x7d\x32\x69\xa6\x0d\x5f\x77\x90\xa8\xd3\x87\xa4\x06\xd6\xd7\x6e\x4f\x02\x4c\x3b\x16\xcb\x9d\xc5\xd2\xa0\x36\x75\x6a\x98\x88\x28\x9b\xd9\x74\x35\x59\xb6\xaa\x49\x34\x8d\x48\xd4\xf5\xd0\x20\x1e\xbf\x0a\x86\x22\xe6\xb2\x4e\x47\xc6\xad\xc1\x24\x96\xab\xdd\x1f\xc1\x35\x52\xcd\xd9\xb9\xec\x03\x51\xc6\x3c\x13\xe7\x4d\xbf\xe7\xe7\x9f\x76\xae\x50\xed\x45\x0c\x98\x8d\x95\xbf\x4f\x13\xb7\x96\x82\x79\x4e\x11\xa6\x99\xae\xa5\x23\xaf\x36\xfc\xce\xb2\x20\xf2\xd7\xf5\x47\x21\x00\xf4\x51\xc4\x84\xf8\xca\xf1\x03\x0a\xec\x37\x11\xa9\x74\xf3\x22\x4d\x4b\x91\x32\xd3\x67\x62\x0c\xdf\x1f\x39\x66\x2f\x9e\x3f\xd9\xce\xef\x3f\xee\xfb\x1f\x7f\x55\x1c\xb1\x55\x19\xfa\x78\x14\xb3\x04\xf7\x9c\x31\x2a\x59\x1a\x08\x79\xca\x04\xc2\x42\xef\x0e\x6f\x2f\xc2\x1d\x43\xd9\x89\x48\x9d\x3d\x79\xdd\x6f\x0c\x0a\x80\x36\xf2\x93\x45\x56\xbb\x7d\xc6\xed\xc5\x79\xa8\x0f\x85\x40\xb6\x81\x4c\x7d\xe1\x23\x13\x94\x11\x29\xc7\x37\xf2\xce\x4e\xcc\x53\x00\xe5\xfa\x7b\x2f\x8b\x4a\x9b\x26\xc4\x32\x0b\x82\x38\x5d\x9c\xd8\xee\xdf\xc5\x12\x54\xd9\x13\x55\xc2\x7f\xcb\x89\xd0\xb1\xbf\xba\xd4\xa1\xda\x62\x62\x69\x4b\x8a\x04\x91\x05\x9d\x02\x3b\x2a\x20\x79\x50\xa6\xc6\x22\x2b\x78\x2a\x59\xbe\x63\x59\x2f\xbf\xd9\x55\x48\xb3\xbe\xbb\x99\xa6\xf2\x86\x33\x5e\x3e\x1c\xe6\xc6\xe4\x75\x8e\xc0\x11\xba\xf6\x0b\x45\xd7\x52\x24\x19\xdf\x69\x54\x75\x42\x9d\x0e\x03\xce\x7a\xb4\xb8\x7c\x90\x96\x1d\xab\xe5\x94\x9b\x9f\xbd\x0b\xee\xab\x3f\xb6\x89\x8a\x57\x24\x49\xb7\xa9\xe0\x51\xe8\xbe\x72\xde\x93\x17\x2e\xd9\xfb\xd4\xd1\x8f\x90\x13\x97\xd7\xc1\xc1\xcd\xd4\x68\x2a\x12\x64\x50\x30\x92\x2d\xb0\x3d\x50\x64\x41\xfe\xe8\xc5\x5d\x5e\x54\xed\xb9\x3c\x8b\x62\xd8\x2e\x33\xe6\x09\xab\xda\x3e\x2b\xc2\xb7\xa6\xbb\x45\x5d\x1d\x5b\x72\xcc\x10\xaf\xdf\x84\x06\x51\x74\xa7\x9b\xa8\x26\x06\xc1\x6e\x05\x66\x57\x1a\xe7\x81\x84\xba\x30\x3a\x89\xe6\x54\x25\xf8\x42\x27\x2c\xf0\x5d\xf4\xf8\x3e\x56\x83\xb3\xab\xea\xaa\xa7\x04\x5f\x57\x8a\x82\xd0\x39\x6c\xaa\x43\x7b\xc0\x0b\x3f\x32\x9e\x5d\x4d\x75\xb1\x4c\xe7\x32\xfb\x04\xe3\x1f\x8e\xd8\xb6\x5e\x49\x54\x51\xeb\xac\xa3\x0a\xa8\x27\x37\xe1\xde\x72\xc5\x73\x3d\x32\x8e\x92\x6f\xe6\x2d\x2b\x9a\x1c\x3e\xa3\x0e\x14\xe6\xfe\x6a\xea\xf6\xda\x74\xaa\x2c\x9d\xf2\x03\xe9\x67\x13\x4d\xc4\x5d\x8b\xe4\x20\x7a\x35\x51\xb6\x4f\x09\x99\x1a\x5b\x5a\x89\x37\xce\x98\xbc\x02\xbc\x84\x7c\xf3\x2d\x7f\xde\x5b\x1d\x17\x8b\x0d\x40\x9d\x30\xa4\x2b\x29\xde\xbd\xb8\x0f\xba\xa2\x4a\xe9\xf9\x6a\xfa\x34\xd1\xec\x60\x44\x43\x38\x13\x80\xb4\xc2\x3c\x28\xc8\x73\x59\x4d\x9a\xe1\x52\xad\x88\xe0\xa2\x10\xdd\x6e\x58\xe8\xee\x47\x40\x97\xb4\x6c\xcd\xef\x61\x01\x72\x9d\x84\xc9\x9b\x1b\x2f\x8c\x4f\x6f\xd0\x2b\x2d\x9f\x3b\x47\xaa\x69\xc1\x58\x8a\x9b\x4c\x33\x15\x0d\xf4\xe5\xd1\x6f\x95\x63\x1d\x76\xe4\xec\xc4\x5b\x48\x6d\x25\x0e\x63\x40\xd1\xd3\x25\x11\x42\x7a\x4f\x5c\x78\x8d\x90\x48\xe8\x96\x04\x33\xbc\x9b\x95\x4b\x00\x77\xe9\x19\xf3\x60\xb9\x58\xe1\x9a\x84\x47\x6b\x27\x57\x8d\x2c\x7e\x27\x7a\xcd\x58\x3d\x8b\x96\x7b\x09\x2c\x21\xe3\xa7\x1a\x4a\x55\x45\xcc\xe2\x4f\xfd\x2d\xe8\x2d\x97\xb5\x36\xe4\xbc\x35\x16\x07\xc0\x75\x51\xf6\xe5\xfb\x23\x0c\xec\x3b\x39\xf7\x1d\xd0\x77\x88\x37\xdd\x5a\xd6\x50\x72\x60\xf0\xcf\x8d\xd9\x90\x55\xae\xac\x84\xfc\x09\xa6\x7c\xee\x21\xa4\x7a\xdb\x11\x99\x6f\x0f\x29\xea\x6f\xa4\x33\x2f\xb8\x1a\x28\x98\x23\x19\xa6\xa6\x95\xf2\x5d\x99\x86\x82\x78\xe3\x0f\xee\xb3\x96\xcb\x9f\x6b\xd2\x39\x0e\x7f\x5f\xea\xfb\xcf\xbf\x10\x55\xba\xc0\xf2\x01\xbd\x15\xb3\xbb\xf2\x34\xa4\x06\x30\x8a\xfb\x4a\xe1\x2b\x3a\xac\xcd\xb0\xa2\x82\x94\xd0\x45\x27\x72\x1e\xca\xea\x19\x1f\xca\x51\xf7\xbc\x6d\xbb\xcd\x3f\x99\xb0\xd0\x82\x07\x79\xf1\x02\xb1\x09\xb9\xc8\x74\xfb\xea\x95\x7e\x31\xd3\x35\xc2\xc2\x9c\x52\x67\x84\x68\x37\x91\x53\x24\x45\x50\x0f\x41\x34\x86\x0e\xdd\x4e\x45\x9c\x95\xb5\xaf\x44\x02\xbb\x76\x7c\xc3\xb6\x42\xf7\xdc\x63\xa7\x83\x9f\xa4\x48\x28\x93\xcd\x8b\xd4\x63\xb2\xfd\xb0\xec\x04\x3e\xb2\x97\x35\xa6\x67\x4b\x87\x55\x5a\x3c\x3b\x2b\x55\xef\x5a\xc8\x68\xee\x96\xb5\x1d\xbc\x6d\x8f\x22\x3d\xbc\xcb\xc6\xb4\xd7\xd4\x34\xbe\x0d\xf3\xf8\xec\x47\x64\x44\x93\x66\xcc\xd6\x1f\x13\xfd\x10\xe1\x9d\x9f\x53\x22\x1e\x7a\xc8\xae\x65\x55\x1d\xf5\x57\x79\x90\x15\x66\xce\xcd\x8f\x1c\xff\xb6\xef\xcf\x0e\x6a\x30\xf8\x89\x26\x04\x1f\xe6\xef\x50\x35\x3e\x86\x2d\xf9\x45\x54\x9e\x1e\x46\xc5\xe1\xb4\x28\x83\xbc\x32\xd1\x80\x89\xaa\x51\x5d\x1a\x34\x05\x93\x64\xe6\x8c\x27\xf7\x8b\x56\x80\x1b\xf2\xdd\xd6\x7a\x90\xa3\xa4\xb9\xf9\x85\x9b\xec\x77\x83\x95\x2f\x7b\x2c\xda\x9f\x8b\x68\xe1\x9c\x32\xcd\xa5\x96\x51\xa8\xdb\x2c\x47\xff\x38\x6a\x39\x48\x2b\x8d\x78\xc7\xef\x6e\xb3\xe3\x13\x5b\x68\x12\x7b\xa1\x34\xf8\xe5\x9d\x76\x8d\x1d\xb6\xb7\x0e\xf0\xc3\xc8\xb9\xf6\xc4\x55\xb2\x35\xfe\xc7\x68\xb5\x3f\xb2\x78\x24\x72\x18\x3d\xb4\x0b\x23\x0b\x6a\x9f\x35\xe9\xa4\x4a\x62\xac\x31\xdc\x6a\xa3\x09\xcf\x41\x26\x9d\x55\xda\x30\x93\xa6\xfc\xdc\xe2\xd5\x04\xf5\xeb\x49\x03\x8d\x3c\xfd\x3c\x76\x12\x58\x97\x35\x53\x73\xbe\xa3\x5f\x78\x95\x72\x19\x93\x2c\x06\x00\x1e\x52\xef\xd3\x4b\x5f\x78\x34\x68\xdd\x09\x6d\x3d\xd3\x71\x17\xfe\xdb\xc5\x34\x08\x24\xfa\xaa\x48\x9d\x56\xeb\x54\x7b\x81\xf8\xe7\x1c\xb0\x58\xeb\xa9\xcc\xc3\xbf\x34\x90\xbb\xc9\x1d\x21\x4e\xb4\xaa\xb1\xf9\xde\xa2\x84\x7c\x9a\x87\xb9\x0e\x58\x88\x73\x53\x59\xeb\xea\x93\xfe\xa4\x4a\x45\xd6\x4c\x57\xf7\xa7\xfe\x0a\x1a\x79\x26\xc4\x58\x66\x90\xc7\x55\xe3\xa2\x99\xe9\x5f\xb9\x45\x62\xa0\x46\xcb\x25\x3c\xc9\x5d\x30\xf3\x34\x71\x38\x69\xd9\x44\xcc\xdf\x3a\x6a\xa2\xcf\xad\x5b\x4f\x4e\x3a\x31\x4f\x12\x35\x2a\xc8\xf9\x07\xf4\x57\x35\x4e\x34\x14\x7f\xb2\x22\xbf\x04\x01\x8e\x90\xc9\xae\xbb\xd7\xf7\xac\xf7\xee\xaa\xd5\x29\x22\x72\xb5\x5a\xd9\xe2\x88\x38\x22\x3d\x6b\xe2\x7e\xb8\xe6\x7a\xd9\x75\x4f\x99\xeb\xd6\xf8\xec\xb3\xa0\x1e\xf1\xbc\xe0\xbe\xd1\x6e\xb1\x46\x85\x47\x8e\x99\xd2\xfa\x7d\x93\x1c\x49\xeb\x6f\x4a\x09\xb3\xd2\x15\xc7\xcc\x55\x32\xc5\x4d\x42\xef\x42\x62\xaa\xbe\xa4\xd8\x0a\xa2\xfb\x3c\x94\x66\x68\xb6\x41\x0c\x71\x6f\x10\x31\x2f\xfe\x48\xc5\x51\x3e\x7f\xae\x2b\x0b\xe6\xff\x5a\x84\x80\x7a\xf2\xf8\xdb\x34\xf4\xd9\x80\xe4\xbb\x1c\xc5\xc4\xe1\xc1\xa7\xed\x54\x95\x6d\x48\x08\x14\xa1\x63\x98\x62\x96\xfb\x8d\xe3\xa4\x33\x52\x5a\xd4\x98\xa4\x23\x02\x24\xb6\x0b\x51\x88\xb4\x41\x7b\x94\x3c\x27\x65\x1d\x67\x6e\x64\xa5\xad\xea\xb6\x65\x64\xd6\xb3\x4f\x98\x1a\xa5\x6a\xca\x09\x5d\xca\x01\x7d\xe0\x59\xb5\x78\x92\x0f\xa3\xb0\xaf\x02\x72\x02\x21\x26\x0e\xcf\x66\x33\xfe\x1e\x45\x63\x71\xa3\xb9\xcb\x8e\x28\x41\x18\x95\x7a\x93\x20\xa8\x9d\x10\xf1\x51\xef\x72\xfe\xae\xd4\x04\xfe\x01\x60\x01\x94\x23\xe0\x64\x69\x9d\x0a\xe5\x05\x93\x2b\xbf\x24\xf7\xa7\xd6\x48\x92\xf7\x2b\x6b\x49\xbf\xa9\x72\xc9\xc6\xcd\xe5\xe2\x6d\x98\x12\x57\x56\x4f\x44\xac\xea\xf5\xbc\x52\xdb\x6e\xa1\xb9\x32\xb5\x78\x29\xf0\x69\x31\xbb\x1e\x22\x0d\x7a\x45\x65\x57\xb9\x3c\x4f\x62\x42\xe3\x64\xfa\x0e\xa5\xc5\xad\xca\x2d\x64\x1a\xc0\x31\xc8\xa9\x45\xfd\x77\x08\x78\x87\xd4\x63\xdc\x92\x3a\xe8\x74\x17\x5f\x85\x9a\xe7\xab\xbc\x31\xdc\xfd\x63\x9a\xf9\xdb\x44\xb6\x72\xc3\xd1\x8e\x7f\x9f\x76\xc4\x41\xe9\xc5\x09\x2e\x4a\x25\xfe\xb9\x94\x08\xe9\x6e\x82\x8d\xc8\xa8\xab\x4c\xc7\x2f\xb8\xc1\x9c\x9b\xc6\x47\x2b\x3a\xe8\x64\x8d\xb5\xb2\x91\x0a\x7e\xaf\xbc\xaa\xb0\x50\xc7\x07\x90\x8c\x7b\x92\x5f\xe8\x20\x91\x46\x86\x9d\x4b\xc4\x11\x40\x13\xe8\x9d\xec\xd8\x29\xb9\x96\x5c\x4d\xfa\x5e\x6c\xf9\x58\xee\xe5\x8f\xdb\xa3\x93\x4b\x40\x54\xe4\x71\x18\x92\x34\x0b\x07\xc8\xb1\x4e\x5b\x1d\xe0\x31\x1f\x85\x54\x49\xfb\x61\xb3\x14\xa0\xb4\xf5\xab\xc4\x62\x78\xa5\x44\xee\xe5\xa4\xdf\x64\x42\x7c\x9b\x49\xa5\xd8\x24\x7a\x01\xba\xad\xf1\xe5\x07\x48\x36\x1d\x43\x10\x42\xe7\x02\x49\x07\x87\x28\x56\x5a\x28\x52\x91\x67\xa2\xba\x96\x60\xb9\x06\x85\x74\xfb\xcc\x1e\xfa\x05\xa3\x25\xd1\x9c\xdb\xea\x33\xd2\x7c\x12\x0d\x3e\x75\xc9\x85\x42\x97\x19\x35\x29\x21\x34\xd1\xab\x53\x04\xf5\x33\x9f\x5b\x85\x77\x82\xef\x50\x3b\x62\x52\x9b\x9d\x71\x21\xe4\x37\xbb\x11\x4b\x32\x89\xc2\x39\xaa\x39\xdc\x22\x1f\x40\x81\x12\x88\x3a\xf4\xa2\xdd\x4c\x5b\xe6\x6f\x5f\xa2\xec\xc1\x77\x43\x2a\xb9\xdf\xe9\xc8\xb1\xe8\xb3\x4f\xe0\x3a\x03\x77\xfc\x2a\x96\xdc\xaa\x2b\xe7\xa6\x7d\x54\x80\xc2\x4c\xb5\x7a\xa6\x77\x9c\x0e\xb4\xc4\x52\x14\x22\x2c\x1a\xbe\xf7\x5f\x8f\x14\x95\x85\xa9\x06\x97\xc9\x03\x95\xf3\xae\x85\x63\x6e\x58\xfc\xec\xd5\xf6\x7e\x66\x9d\x26\xab\x6f\x36\x87\x60\xfb\x9e\xaf\x4e\x81\x17\x84\xc6\x52\xbf\xd8\x2f\xd6\x02\x75\x69\x88\x7d\x55\xe3\x9e\x46\xe9\x9f\x9b\xf3\x95\x87\xe3\xd7\x88\xf5\x2c\x02\xcc\x55\x83\x47\x1f\x46\x09\x36\x96\x2d\xfd\xc5\xa3\x76\x88\xe8\x18\xbd\xcc\xef\xbc\x35\x03\x45\x33\xb2\x3a\x09\xb5\x51\x78\x66\x03\x1b\xbd\x22\xe2\xa1\x5b\x51\xa5\xc3\x28\xc7\x28\xdc\x1a\xa7\x8c\x5b\xeb\x7f\x65\x6a\xf6\xf1\x75\xe5\xd1\x5f\x0d\x8c\x1c\x18\x12\x9e\xff\xb5\x24\xf4\x7f\x24\x4e\xaa\xe1\xfa\x53\xe1\x64\x3c\xfe\x6e\x60\x86\xbf\x5d\x71\xe0\x5b\xd9\xbe\x6b\xb1\xcf\x46\xc5\x92\xb2\x54\x1d\xce\xae\x57\xd3\xaf\xd0\xd6\xad\x23\xc6\x80\xda\x5d\xe7\xe9\x6d\x20\x4a\xa3\xa8\x6e\x81\xf5\x03\xd6\x7a\x5c\xdd\xf2\x9e\x4e\x90\xd3\xc9\x9d\xd8\x2a\x72\x52\xbb\xb2\x28\xc8\x73\xe4\x72\xd0\x81\x24\x48\x31\x15\x04\xf4\x2d\xb2\x97\x7e\x67\x32\x2a\x9f\xf5\xb7\xa9\xee\x98\xea\xbc\x6d\xb3\x0f\xd2\x3d\x38\xe5\x06\x48\x8a\xa8\xa1\xfe\x94\xc7\xe2\xd6\xea\x63\x21\x23\x8c\xc2\xdc\x8c\x22\xae\xfd\xc2\x3d\x18\x3b\x6f\x71\x15\x3b\x4e\x4c\x64\x8a\x23\x3d\x20\x38\xee\x44\x0c\x60\x56\xd4\xd8\x51\xec\xf4\xa9\x23\x4d\x09\x62\x77\xc9\xb1\xe4\xa5\x15\xab\xa5\xd5\xb2\xbc\x64\x29\x3c\xb5\xe7\x83\xc1\x63\x0d\x82\xdc\x3a\xec\xb1\x5b\x23\xed\x77\x98\xc4\x98\x7f\x06\xc2\x29\x08\xc0\xbc\xac\x56\xb3\x8c\x84\x36\xa6\xc0\x0b\x44\xce\x2d\x9f\xc5\x3a\xaf\xb9\xa4\xa5\x26\x46\x6e\x0e\x5b\x1a\x22\x65\x53\x88\x44\xa9\x63\xb3\x16\x5f\x87\x32\xac\xef\x4e\x40\x07\xeb\x76\x67\x11\x95\x49\x4f\xd6\x98\xea\xd2\x2a\x60\xf6\x2d\x9c\xb9\xc1\x3d\x4e\x06\x30\x73\x38\xc6\xa7\x1f\x2b\xc7\xaf\x56\xd9\xc5\x20\xfa\xb9\x62\x97\x61\x28\xa3\x43\xa3\x4d\xf6\xe8\xb3\x73\xb3\xac\xa7\x67\xf4\x4c\x6b\x6c\x72\x84\x35\xde\x6e\x6e\x21\xbf\x02\x72\x5d\xb0\xa4\xcf\xe6\x37\x6c\xf3\x20\x2c\x32\x63\x1b\xf6\x0d\x2f\xab\x52\xac\x3b\x3d\xc8\x79\xc9\xfc\x68\x85\x95\xfb\x9e\x07\x85\x64\xef\x23\xce\x0e\x9c\xe8\xc6\xe5\x58\x6a\x79\x68\x62\xf8\x3c\xb5\x22\xd7\xbd\x94\x49\xbc\xc3\xde\x8e\x68\x1e\x4d\x73\xba\xc9\x1e\x4b\x57\x16\xb3\x90\xee\x72\xd6\x9b\x9c\xca\x60\x81\xfc\x6e\xb5\xfd\xb2\x62\x78\x2d\x2d\x90\x08\x5b\xab\x01\x45\x65\xe2\x6f\x9e\xb7\xe7\xeb\x3e\x64\x76\x3e\x7f\xf6\xe6\x94\xbf\x29\xf5\x35\xc9\xc8\x0e\x31\x9a\xc7\xba\x4d\xf0\x70\x3a\xa3\xe3\x20\x30\x1e\x36\x81\xd4\x14\x71\x67\x80\x73\x3d\x7a\xe6\xda\xb2\xc3\xde\xdb\x7b\xdd\x6c\xd8\x7f\x26\xcf\xcd\x59\x23\x0c\x7a\x1e\x3d\x9b\x74\x03\x74\x26\x1b\x7c\x67\x44\x75\x46\xbc\x38\x33\x15\x5a\xd3\x93\xb9\xd3\x4b\x52\xc6\x11\x35\x5a\xf3\x4d\xab\x08\xcf\x5e\x34\x1b\xb7\xa6\xe9\xc8\xa4\x9c\xaa\x96\x9b\x28\xba\xea\x6d\xc9\x54\xef\x50\x7c\xc2\xa6\x06\x8d\x9d\x19\x4f\xd0\xd8\x4e\xca\x42\xb3\x6f\x8f\xdd\xd7\x4a\x93\xcc\x29\x08\xe1\x0f\x8b\x3d\xce\x07\x5f\x00\xc2\x98\x9d\x30\x64\x6b\x2e\x0e\xeb\xf9\xec\xf3\x54\x78\xd4\x15\x03\xf0\x42\x2b\x45\x99\x38\x78\x25\x23\x18\xc6\xd6\x36\x6b\xc0\x34\x6a\xfe\x6e\xa2\xee\x6d\x22\x2f\x34\xdf\xa4\xd5\xa2\x09\xf0\x53\x70\x2f\xa4\x2f\xc0\x89\x1c\x3d\x9c\x2c\x59\xb2\x50\x43\x6d\x8a\x51\x61\xaf\xca\xc4\x6e\x88\x29\x08\x0e\x08\xa4\xed\x98\xde\x2b\xac\x06\xdc\xab\x5c\x4a\xfb\x0f\x6d\x91\xd6\xed\x9f\xab\xc7\x31\x06\xff\x60\x48\xfe\xa7\xe2\x00\x8f\x6d\x19\xe8\x75\xd0\xa0\x21\x6d\x6f\x14\x7a\x68\x97\x79\x79\x45\x4e\x04\x31\x98\xdc\xab\xfb\x75\x40\x1d\x3e\x46\xa4\xac\x44\xb0\x65\xdb\x2d\x10\xcd\x0f\xca\x5d\xa3\xd1\x1d\x69\xee\xf8\x93\x66\x03\x46\x1d\x25\xdc\x55\xec\x57\x29\x23\xe7\xf9\xbe\x8b\x2a\xde\xc4\x6a\xd9\xc3\xc0\x06\xbd\x24\x49\x0c\xf9\xa6\x8a\xc2\x90\x27\xcf\xd1\xe6\x3b\xb8\x2f\xf9\x01\x2c\x5e\xd9\xba\x44\x57\x05\x0a\xea\x8c\x20\x02\x0b\xde\x80\x13\x6a\xd2\x25\x3d\x8b\x86\x37\xb7\x60\x69\x8e\x00\x8d\x41\x9a\xea\xa4\x5a\x83\xa7\xe3\x7c\xbc\xf0\x15\x2c\x49\x31\x1f\x46\x94\xe7\x3a\xaf\x22\xda\x9d\x3c\x29\x9c\xed\x9c\x5b\x6c\xf4\x5a\x5a\x17\x38\x6a\x3a\x76\xb8\x85\x7e\xc7\x4c\xbc\xbe\xd7\x4d\x7d\x45\xe3\x4f\xa0\x86\x51\x16\x6a\x8a\x87\x48\xae\x43\xc2\xce\x12\x8c\xa1\x20\x57\xb0\x85\xcd\xb0\xcf\x9a\x9c\xc0\x59\xaf\x53\x38\x87\xd4\x7e\x1b\x58\xd9\x2c\xb0\x31\x1f\xb5\x3c\xe3\x99\x68\x87\xe2\x91\xba\x24\x70\xd9\x58\x40\xa5\xd0\x89\xb9\xc0\xaf\xae\x68\x86\x6f\x07\x7a\x2d\xfc\x7a\xa4\x48\x89\xbb\x7d\xbb\xe7\x3c\x52\x89\x66\xcb\x5a\x01\x66\xd6\xb1\x9e\x8d\x47\xc1\xa3\xba\xed\x9d\x7e\x40\xd3\xd3\x07\xd1\x94\xcc\x43\x16\x4d\xe6\xde\x34\x3b\x7a\xb4\x7f\x7b\x75\x31\x24\x20\x1b\xa8\x4a\xaa\x4d\xf2\x4f\xe4\x48\xaf\xed\x93\xd6\x72\x1d\x52\x7c\xda\x8c\xcc\x1b\x89\xc2\xc6\xc4\x7b\xea\x3b\x94\x6e\x89\x00\x6a\x41\xdf\xef\x35\x9f\x7b\xd9\xc9\x3a\xdd\x84\x25\x8e\x9d\x92\x5f\x70\xd1\xdb\xd2\xf1\xe3\xa4\x26\x39\x09\xe4\x89\xa2\xc4\xe2\xae\xed\x7a\x9b\x90\x74\x7d\xf3\x6b\x1a\xe3\x7a\x86\x3b\xb6\x83\x20\x8a\xd0\x88\x3c\xfb\xb1\xce\x5b\xd1\x42\x64\x9c\xd4\x05\x38\x81\xe1\x24\xa1\xac\x9f\x9c\x62\x9c\xb1\x4e\xa7\xdc\x9b\xfb\x82\xd8\xb0\x66\x7d\x9c\xf4\x21\x04\x1c\x4d\x22\x22\x46\x93\xde\x26\x70\x37\x20\x60\xb6\x4e\x3f\xb4\xaa\x28\xcf\x07\x3f\x53\x88\x38\x96\x22\x66\x23\xb0\xb1\x6f\x37\x1f\x49\x79\x48\x28\x27\x7e\xa9\xeb\x96\x1c\x8d\x34\x68\x32\xa0\x0e\xa4\x98\x7c\x12\x7a\x8b\xfc\x09\xe8\x04\x8e\x14\x85\x65\x46\xb1\x26\x37\x83\x8f\x50\x2d\x54\x07\x42\xf7\xf8\xf5\x01\x6a\x1c\xde\xc2\x2e\x0e\xab\xfc\x44\xf2\xc1\xe7\xdc\xf1\xa3\x1d\x9d\x3f\xd4\x22\xa8\x93\x0c\xa8\x6e\x1a\x12\x61\x16\x6e\x22\x1d\x4a\xbc\xc4\x70\x72\xb7\x82\xb2\xdf\x32\x46\x2d\x71\xc6\x53\x27\x03\x5a\x95\x4e\x23\x56\x39\xf6\xae\x92\x8c\xfc\xa8\xf9\xa6\x12\x2d\x78\xca\xb5\x05\x78\x37\x20\x0c\x0e\xbf\x4a\x06\x56\x3d\xe0\xf5\xfa\xe8\x29\x31\x3c\xee\x9b\x68\xcd\x85\x6b\x0f\x2a\x42\xaa\x9d\xfa\x93\x47\xa5\xd0\xe3\xde\xa9\x50\x50\x00\x49\x66\xff\x6b\x27\x42\x21\x69\xba\x1b\xeb\xde\xaa\x3a\x1f\x68\xf7\x3f\x14\x0d\xcd\x9f\x0a\x0c\x99\xf3\xf7\xc5\xcc\xfe\xa7\xdd\x10\x6d\x4f\x15\x74\xcf\x2a\x74\x1c\xc1\xba\x40\xcd\xbd\x06\xec\x00\xf8\x0c\xef\x78\x14\x2a\x10\x0f\x41\xb2\x15\xea\x7f\x3f\x82\xe2\xbc\x1f\x2a\x90\x61\x16\x4b\x87\xd3\x33\xb1\xa3\x19\x2b\x77\x14\xa9\x95\x68\x66\x76\x6a\xfb\xcf\x10\x87\x28\x0f\x39\x25\x11\xb3\xf2\x05\x1e\xc2\xf6\x79\xbb\x96\x57\x0f\x22\x2c\x0d\x0b\xd5\x46\xd2\x30\x09\xc5\x15\x00\x86\x57\x18\xbe\xf6\x70\xc9\xc2\xbb\x98\x1c\x74\x56\x48\x48\x33\xda\x0f\xce\x3f\xd1\xef\x78\xa3\xb9\x3a\x34\x3f\x64\x1e\x0d\xff\x3f\xf6\xde\xb4\x67\x75\x64\x69\x10\xfc\x2b\xa8\xa5\x57\x67\x5a\x34\x78\xdf\x66\x54\x1f\xbc\x63\xbc\xe0\x1d\x9b\x2f\x2d\x6f\xd8\xc6\x1b\xe0\xdd\xf3\xe7\x47\x36\xcf\x39\xa7\xee\xad\xaa\xbe\xb7\x75\x6b\xa4\x6a\xa9\x8e\x78\xf2\x98\xcc\xc8\xc8\xc8\xd8\x32\x22\x30\xe6\xfd\x20\xbd\x4a\x77\x4a\x59\xa1\x6a\xd6\x8f\x2e\xc2\xc2\x53\x0f\xe8\x22\x5b\x36\x1b\x3f\xe2\x77\x97\x2b\xf1\x9b\x90\x33\x37\x5d\xf8\x61\xbc\xe2\xc5\x9b\xa5\x60\x1e\x2f\x50\x39\xa6\xc2\x73\x87\x11\x67\x17\x1b\x04\x19\x96\xef\xa6\x61\xba\x7b\x93\x56\x8b\x65\x4a\x4b\x5f\x82\xcc\x80\x9b\xe1\xf8\x0a\xbd\x9f\x57\xf3\x61\x34\x98\x2b\xe6\x91\x2f\x35\xef\xab\xdb\x34\xc2\x60\xb8\x2c\x4b\x3f\x44\xf2\x52\x8d\x90\x9a\x8a\x24\xad\x82\xbd\xc5\x38\x9c\x55\xb3\xf7\x02\x90\x44\xf6\x34\xde\x11\x8e\xe5\x00\xc2\xc9\x2e\x0a\xf3\x16\x0a\xae\x4f\x9e\x40\xc6\x39\x96\xc5\x0e\x50\xee\x37\xe8\x5b\xba\xbf\xc4\xb1\x72\x2c\xed\xfc\xb8\xfb\x21\x13\x19\x72\x76\x1b\xc1\x80\x51\x69\x94\x41\x49\x65\x64\x32\xa6\x03\xa2\x8b\x46\x82\xa7\x4a\xa5\x34\x03\xbf\x7b\x29\x70\x2d\x8b\x1e\xb5\xc7\x4a\xbb\x72\x4b\x60\xbc\x96\x93\xb8\x07\x75\x4b\x6e\x62\x2c\x3a\x61\x6e\x06\x9b\x39\x9d\xf9\x72\x44\x72\xa5\x0b\x39\xba\x35\xf7\x82\x2a\xce\xa9\x5b\xaa\x29\x04\xe8\x38\xc3\xe2\xdc\xcb\x33\x64\xf2\xa1\xdd\x38\x8f\xf6\x69\xe8\x0e\x43\x2e\x82\x8e\xaa\xe7\x0b\x41\x3e\xbb\x23\xf8\x3e\xcf\x8b\x92\xb6\x88\xab\x16\xd3\xe5\x21\x76\xf9\x04\xb8\xa0\x77\x65\xb3\x1b\x18\x49\x70\x0e\xc4\xcb\xe0\xc5\x77\x3b\x06\x8d\x3b\x05\x31\xaa\xfe\xce\x66\x6d\x49\xe5\xfb\xa5\x9a\x82\xeb\xfc\x7c\x05\x9c\x77\xda\x1e\x37\xd8\xb1\x0a\xe9\x5d\xee\x02\x4a\xfc\xb9\x4f\x13\xcb\xfe\x62\xdf\x22\x4a\xb2\x5f\x7f\x29\x6f\x00\x41\xda\x39\xc9\x80\x27\xdf\xa1\xf9\x16\xf3\x96\x6b\x32\xde\xc3\xb4\x4c\xe1\xa5\x1a\x2e\x43\x63\x52\x84\x49\x08\x57\x8f\x3c\x90\x3e\x6b\xa5\x9e\x45\x44\x49\xbd\xb4\x9c\x50\x87\xe3\x94\x9b\x05\x9a\xd7\x82\x53\x72\x73\xb2\xfa\xb6\xa0\x7a\x5c\xf4\xac\xa4\x0a\x2b\x25\xbd\xde\x42\x8f\xd8\xc3\x61\x7d\x2b\x29\xb8\x4a\xc1\xb4\x69\x90\x10\xb9\xdf\x2f\x40\x1d\xc5\xc3\x7c\x7f\x9c\x92\x3b\xfe\x82\xb9\x72\x68\x49\x03\x2e\xba\xe5\x0d\xe1\x7b\x4b\xc1\xc1\x47\x96\xdd\x70\x2a\xbc\x90\x1e\xc9\x96\x0a\x4b\x8c\x94\x17\xcb\x67\x57\x24\xef\xbd\x0a\xbe\xa1\xeb\xfb\x2c\xa2\xa9\xf7\x48\x5f\x0e\xc4\x81\xaa\x18\xc1\x05\x63\xcf\x5d\xb9\x27\x02\xca\xab\xae\x51\x09\x49\x0c\x90\xdd\x64\x3e\x8b\xa2\x17\x16\x9c\xcf\x40\x82\x84\x76\x4f\x5c\x53\x88\x75\x1b\xe2\xad\x29\xa5\x99\x39\x19\xda\xa8\xb5\xd7\x70\xcd\x9c\x35\x27\x71\xbe\x56\x4e\xb2\x37\x9c\x90\x57\xa4\x80\xb8\x92\xec\x83\x16\x4a\x75\x89\x97\x24\x2a\xd8\x51\xd0\x40\x9c\xb6\xe9\x9a\x34\x2a\x4e\x55\x55\xb1\x54\xfb\xf1\xda\x47\xcf\x86\x3d\x69\x09\xfa\x60\x0a\x5a\x4d\xea\x87\x3f\x98\xba\x3d\xe7\x18\x72\x1e\xfa\xd1\x23\xe9\x67\x59\x26\x74\xc2\x44\xa6\xf0\x3e\xe1\x6f\x4f\x9a\x94\xbc\xa2\x24\xe0\x99\x23\x06\x0d\x99\x99\x1c\xf8\x53\xfc\x28\x34\x52\x1a\x83\x92\x55\xa5\xf1\xda\x52\xe5\x43\x2d\x32\x70\x5c\x8a\x3d\xa5\x12\x23\x44\x50\x2c\xa2\xdc\x34\x6f\x1a\x12\x38\xdb\x47\xc8\xa9\xa7\xa0\x53\x22\x57\x1c\x80\x2f\xa7\x8b\x52\x8f\x24\x92\x97\x0c\x04\xb8\x20\x9b\xbc\x1c\xc4\x20\x21\x85\x05\x2e\x28\x14\xc2\x4c\x37\xc1\x1a\x7c\x76\x75\xf8\x9d\x9b\x64\x62\x3b\x53\x95\x83\xf6\xc2\x8c\x6f\xf9\xa6\xb6\x2f\xb5\x59\x48\xb5\xe5\x32\x80\xbb\xf6\xd7\xcc\x61\x64\xc7\x54\xe4\xc9\x90\x92\x8b\x7a\x6d\x9e\x9d\xaf\xd7\x16\x14\xed\x25\xed\xc6\x14\xa3\x64\x35\xd5\xc5\x6a\x2b\xe6\x66\x11\xcc\x1e\xb9\x5e\x96\xdb\xf0\x96\xc5\xa5\x50\xe9\x5c\x7c\x69\x33\x91\xee\x95\xca\x2c\xcc\x7b\x52\x30\x35\xad\xcd\x30\x84\x23\xfa\xcd\x7b\x5b\xe1\xdb\xc0\x87\x28\x83\x28\x6f\x21\xef\x3a\x77\x9a\x15\x84\x32\x96\xe2\xc4\xc8\x49\xec\x3d\xee\xfd\x7e\x46\x68\x5a\x74\x10\x42\xd2\x98\x73\xd7\xfc\xa9\x4f\xe3\xca\xba\xaa\xfc\x4b\xd9\x5c\xf5\xab\x27\xd4\x16\x5f\xb1\x6b\xe5\xe3\x20\x16\xec\xb3\xec\x66\x33\x9a\x6c\x72\xf4\x53\x7b\x5f\x25\x93\x46\x6b\x9e\x71\x6e\x71\xc5\xa6\x8a\x96\xa3\xaa\x8c\xdd\xf7\x82\x16\xf7\x48\x28\x0c\xd0\x19\xe2\xbd\x0b\xc7\x9a\xd0\xf9\x6c\xa9\xf6\xf8\x7c\x39\x3a\xae\xe5\xec\x33\x81\xc0\xdb\x63\x41\xb2\x07\xa6\x56\x48\x6e\xcd\x61\x89\x10\x8f\xfa\xbe\x8f\x30\xe4\x51\x71\xa1\xf6\xcc\xa9\x24\xdc\xe3\x42\x17\xe5\x6d\x12\x50\x20\x15\x5e\xb5\x45\x0b\xf1\x78\x5c\x2c\x4f\x2e\x32\xa9\x03\xde\x10\xba\xc7\x20\xec\xc5\xbc\x2a\x8e\x26\x4f\xcf\x97\x1c\xa4\x19\x86\x78\x41\xf3\x0c\xcb\xa7\x14\x26\xfb\xa2\xe6\x9e\x02\x9d\xe9\x41\x08\x73\x23\x68\xcb\x83\x29\x13\x65\xa5\x5d\xb8\x25\xd1\x99\xf4\x56\xca\x54\xe3\x5c\xad\x67\xe5\x6a\xf1\x53\x72\x48\x7b\xff\x08\xd4\x76\x56\x03\x0e\x55\xb9\xe8\xe6\x06\x7b\x2d\x3b\xab\x1a\x08\x8e\x60\x8d\xbb\x70\xad\x21\xb3\x91\xc6\xa7\xeb\x2d\x48\xf7\xca\xe2\xeb\x76\x53\x49\x74\x67\x83\xf6\xc9\xed\x74\x31\xa8\xab\x10\x60\xc2\xc7\xa8\x08\xc5\x50\xc3\x52\xd7\xf9\xa2\xff\x2c\xe5\x99\x5b\xda\x53\x46\xa4\x71\x35\xd3\xd7\x7b\x86\x2d\xee\x0b\x14\xfb\x2c\x45\x4d\xfa\x24\x38\x59\x75\x1f\x5e\xc8\x03\x42\xd0\xc0\x6b\xc8\x30\xde\x4b\x76\xad\x0a\x97\x4b\x33\x38\xd8\x23\x14\xcd\xe6\x36\x6a\x93\x50\x43\xd1\xd4\xd3\x52\xc4\x5d\x81\xf6\xc6\x3d\x68\x20\x42\xfb\x3d\xa3\x4d\x97\xf3\x3c\xbd\x82\xa4\x7e\x4a\xc8\x42\x92\xa9\x7a\xd7\x6b\xea\x34\x50\xe4\xc9\xb8\x59\xb8\x19\x2c\x57\xbc\x78\xf0\xd3\x20\xe4\xa4\x2d\xc6\x9c\x35\x03\x57\x90\xaf\xee\xa8\x62\xe1\x26\xd9\x0e\x10\xc4\x54\xf7\xc5\x1a\x0b\x3d\xaa\x08\xf4\xdc\x50\x7c\x0e\x8a\xb7\xb4\x2a\x46\xd2\x60\x2f\x41\x43\x5e\xbc\x28\x58\x00\x6c\xb0\x6e\xb5\x1e\xd7\x4f\x84\x7e\xbe\x18\x46\x29\xae\x67\x1e\x64\x73\x82\xb6\x96\x50\xca\x58\x45\x31\x20\x1e\xcc\x2f\x05\xc3\x65\x94\xf6\x74\xd2\xdc\x49\x1e\x0d\xd9\x68\xfd\x79\x9c\x6b\xd0\xd7\x69\xa6\xab\x31\xc8\xf1\x05\x21\x1f\x44\x64\x66\x44\x56\xbb\x15\x3d\xd7\x45\x80\x7a\xdd\xdf\x0c\x09\xb9\xbc\xfd\x27\x13\xd0\x26\x2b\xf7\xf7\x02\x61\x30\x4f\xca\xaf\x73\x96\x2b\xd8\x85\x7b\x92\x7b\xe1\x2e\x9c\x4e\x7b\x39\x97\xad\xd7\x55\x76\x14\xf2\xce\x02\xda\x52\x8b\xa5\xce\x54\xcb\x1e\x46\xe3\xdb\x43\xae\x39\x90\x3d\x73\x91\xda\xcc\x57\xd0\x7a\x79\xbd\xda\x9d\x18\x61\x24\xde\x99\x44\x73\x10\xff\xd6\x1c\x2d\xb8\x4f\x32\xa3\x25\x43\xf0\x1c\x7b\x1c\xd3\x9e\xbc\x81\x0a\x2f\x4f\xa2\xf7\xa6\x1a\xe3\xee\xc8\xe8\x48\xa4\x5b\xbc\x19\xe2\xa9\x22\x09\xd2\x0b\x87\xf6\xce\x4b\xbc\x06\x42\x1c\xbd\xdd\x0e\x28\x2b\xba\xbf\x3e\xe8\x1c\x0e\x72\x55\x18\xab\x8b\xdf\x4b\x67\x40\xc3\x55\x98\x1c\x46\x49\xa5\xd5\x46\xe3\xe6\x14\x7d\x47\x0e\xf5\x67\xfa\x84\x3c\xfa\x6b\x7d\xbe\x96\x99\xbf\x72\x09\xc2\x8f\x2f\xf3\xc6\xef\x80\x08\x15\xed\x99\xc3\xf4\x64\x08\x72\x50\x16\xe7\x77\x93\x49\x6c\xee\x17\x9e\x1e\xa4\xde\x7b\x22\x48\xee\x8e\xca\x28\x29\x72\xcc\x52\x19\x89\xae\xa8\x99\x73\xe1\xb4\xc9\xc0\xa2\x9c\x2f\xce\xee\x8b\xeb\xce\x62\xa5\x5e\xdf\x2c\x6d\x9b\x61\x0c\x27\x51\x63\x61\x3d\x12\x34\x43\x95\x2c\xed\xd0\x53\xdb\x7d\xc8\x7a\x2e\x97\x99\x84\x7a\x0a\x11\xc1\x6f\xcc\x57\x48\x48\x91\x78\x85\x4f\x33\x85\x46\x7a\xa0\x8f\xa7\xea\x54\xeb\xd5\x5d\xbc\x02\xd7\x7e\xd8\x2b\xcf\x71\x8c\xeb\xc4\xf4\x99\x89\xd0\x93\xab\x0c\x8e\x17\xdf\xcf\x22\x6f\x9a\xa3\x42\x74\xa1\x7b\x1c\xd6\x61\xaf\xb6\x5e\x54\x94\x2f\xdd\x3c\x1b\x93\xa0\xca\x0b\x6a\x4e\x1c\xdb\xb9\x17\xb4\x45\xa6\xd2\x7c\x5c\x1b\x06\x14\xfc\x47\x69\xe8\x3c\xcf\xe4\x09\x9b\x8d\x32\x6b\x8a\xea\x84\xf5\x4a\x17\xc8\x2d\xa4\x63\x49\x4e\x4a\x72\x29\x06\x80\x5f\x78\xaa\xe7\x77\xa5\xcd\x73\x65\x5b\x8f\x40\xa5\x7a\x19\x73\x8e\x5e\x93\x25\xe3\x43\x19\x3d\x03\x54\xe7\x9f\x6c\xd3\x38\xb3\xf4\x6a\x31\x15\xcf\x44\xa8\x81\x59\x67\x7c\xd1\x20\x05\x45\x42\xe4\x2b\x77\xa0\x7d\x2c\x91\x47\x60\x7c\x6e\x48\xcd\x43\xa2\x08\x82\x62\x6d\xdf\x44\x1f\xa3\xcd\xdc\xf7\x6f\x42\xa4\xc7\x0c\xa4\x27\x36\x57\xf0\xb3\x6a\x03\x20\x3a\x18\x04\xd5\x93\x81\x04\x5f\x00\xe2\xbc\xa4\x38\xd5\xe0\x62\x43\x26\xe3\x1c\x39\x41\xd6\x31\x4f\x9a\xcb\x4e\xb2\x52\xcb\x40\xe2\x86\x85\x1a\x77\xe6\xe5\x2a\x0d\x24\xa8\x19\x70\xab\x67\x75\x44\x53\xa7\x6e\xac\xf7\x54\x76\x13\xc1\xb7\x8f\x73\x8b\x30\x9e\xcb\x3d\x11\x67\x2d\x78\x6b\x3b\x67\x26\xdf\x71\x3f\xea\x16\x30\xc6\x40\x92\x55\x39\x52\x8c\x2f\x74\xb1\x4f\xf9\xd5\x49\xbd\xe7\x9e\xef\x15\x52\x18\xb4\x41\x28\x31\xb3\x46\x27\xda\x22\xf1\x7c\x96\xe0\xc2\x47\x6a\x50\x1d\x50\x92\x99\xdf\x17\xa3\x0a\xea\x28\xce\x49\x09\x94\xa3\x07\xe2\x60\x79\x4f\xc3\xd4\x44\x27\xa5\xcc\x3a\xa7\x37\x2f\x05\xf3\x52\x76\x41\x2a\xc2\x3c\x2a\x8d\x85\x10\x18\xa9\xc5\xe2\xa5\x2f\x81\x54\xae\x81\x31\x29\x75\x58\xaf\xb9\x58\x2d\x62\x6d\x7a\x8e\x65\x9f\x05\x45\xf2\xda\xd8\x97\xdb\xc0\x48\x96\xa0\xf1\xcc\x54\xb7\xfd\xc2\x21\xa2\x87\x0e\x77\xae\x6d\x97\xe5\x45\xf7\xe0\xa3\x38\x1b\x5c\x12\xb3\x62\xc8\xe0\xf4\x35\xc5\xd0\xa7\x1f\xea\xcd\x5e\x13\x5d\x3d\xb6\x53\x9a\xa7\x5f\xc6\x8b\x00\xf5\xb9\x93\x94\x3f\xf7\xbb\xf7\x79\xdb\xfc\xa5\xcc\xf5\xf1\xf3\xe3\xf0\xa2\xed\xde\x0e\xc8\x3b\xd3\x1b\x28\xb0\x57\x78\x5e\x62\xdd\x7f\x8a\xc5\xb3\x75\xce\x0d\x0d\xbf\xa0\x46\x79\xd8\x71\x2e\xe6\x12\x8b\x45\xbd\x77\x2a\xa7\x81\x62\xf8\xcb\xdb\xea\xec\x81\xa9\x8d\xc1\x7c\x5b\xb4\xd4\x26\x0f\xf6\x5d\xbe\x9e\xad\x63\xbe\xe0\x8c\x3d\x6b\xc6\xde\xd6\x94\x0a\xeb\x23\x60\x42\xd4\x6a\x39\x67\x08\x5a\x71\x5a\x3d\x0c\xb5\xb6\x5c\x78\x54\x14\x2f\xe3\x44\xee\x3b\xca\x33\x8a\x7b\x0d\xba\x3c\xe8\x63\x00\x71\xdb\x17\xa7\x6a\x1f\x0f\x97\xac\x8b\x11\x9d\x8a\x80\x69\xd4\x6e\x19\x51\x5f\x03\xd5\xef\x34\xa7\xf2\x00\x21\xea\x80\xa1\xd4\x08\x80\x3c\x63\x81\x69\xa6\xf3\x52\x91\xd3\xf2\x34\xb9\x87\xc8\xc3\x81\x7b\x42\x5d\xfb\x15\xd7\x8d\xe3\xa7\x80\x57\xf0\x59\x35\xef\xd9\x09\xe1\x32\x1a\xeb\xd4\x25\x16\x9a\x72\x48\x31\x75\x42\x84\x89\xb2\xaa\x13\x78\x96\x52\x82\xba\x35\xc8\x03\x15\x69\x4e\x95\x9a\xe2\x6c\xcb\xdd\x23\xbc\xd3\xb2\xe7\xa0\x3e\x00\x6b\x83\x75\x9f\x4f\x04\x66\x0b\x97\x29\xa0\xd8\xea\x0d\x7a\x75\xa9\xaf\x3a\x9d\x5c\x0c\x7c\xd4\x54\xae\x6d\x04\x0f\xa7\xf9\xf2\x65\x94\x9a\x0b\xc9\xed\xa5\xd7\x46\x0b\xa0\x45\xe1\xc1\x3b\x12\x97\x55\x35\xb6\x07\x38\x55\x85\x70\x80\xca\x53\xa6\x19\xe9\x45\x90\xa5\x76\xd4\xcf\x6f\x5c\x7d\x94\x93\xa0\x23\xad\x0b\xa2\x69\xa0\x13\xe6\xa2\xea\x09\x3e\x0d\x57\x15\x4a\x35\x87\x51\x61\x47\xf6\x4b\x26\xe8\x11\x23\xcd\xc4\x67\x96\xc2\xd4\x19\x49\xb9\x52\x51\xf2\xf2\xaa\xc5\x1c\x92\x16\x83\x24\x71\x66\xc6\x51\xb3\x98\xc0\x15\xeb\x82\x2e\x7a\x12\xbc\x9e\x9d\x6c\x8c\x2b\x07\x92\x5b\x90\x56\x2a\xe8\x16\x44\x84\xa0\xe4\x26\x46\x35\xac\x8e\x62\x4c\x46\xcd\xb4\x3a\xea\x2f\x44\x3c\x3b\x30\x19\x51\x5d\x7d\x27\x59\xc0\x00\x6f\x9d\x89\x8a\x52\x95\x18\xd6\x83\xa4\x75\xc5\x3c\x11\x04\xcc\x5c\xa3\x34\x17\x2e\xdc\xfd\xce\x0e\x40\x47\x9e\xa8\xee\x02\x0e\x88\xf9\x70\x09\xf7\x55\x24\x89\xa7\x94\x0b\x77\x1f\xfc\xc7\x83\x24\x7b\x2f\x2b\xd1\xf3\x28\xb5\x6f\x7f\xaa\x14\x1f\x50\xa1\xd4\x8f\x4a\x69\x10\x79\xea\x71\xbb\x6b\xfa\xdb\x62\x39\x04\x30\x52\x65\x4e\xae\x36\xcd\xb9\xf8\x78\xa5\xe8\xf7\x2c\x45\x6c\xc1\x80\x3d\x44\xbf\x80\x86\xd5\xfb\xaa\xec\xef\x8d\x40\xc0\x83\x94\x25\x81\xc2\xbd\xd1\x91\x55\xa4\xcb\xeb\xed\xd7\x8e\x42\x43\xa8\x6e\x35\xaf\xa7\x75\xe6\x69\x27\x2f\x6f\x6f\x8e\x20\xac\x01\x51\xe4\x7d\x24\x81\x7b\x26\x21\x23\x3a\x0c\x2b\xfa\xf2\x6e\x42\x30\x48\x3b\x0e\xa5\x20\xc5\xbf\x17\xcd\x6b\xa8\xe7\x9b\xd2\x5e\xcd\x82\x06\xd2\x62\xa4\x19\x05\xb5\x10\x85\x20\x3d\x7f\xfe\x33\x4f\xe3\x47\x30\x04\x7f\x2d\xfb\xfe\xfe\xa8\x9a\x27\xe9\x80\x9f\xac\xb8\xd6\xf2\x0b\x3f\x27\x4f\x63\xce\x8c\x26\x34\x19\xab\x74\xa5\xc6\x64\x19\x5e\xb7\xe9\x87\xd1\x5a\x7c\x9d\xf0\x7b\xba\x26\x05\x75\xb5\x73\x45\x6b\x8c\xb8\x97\x68\x1e\x79\x35\x4f\x59\x3b\xd3\x92\xf4\x7c\xd2\xf0\xe3\x7d\x31\x29\x24\x08\x70\x40\x23\xe7\x5b\xef\x4c\xf3\x54\xbc\xbd\x37\x72\xbf\x57\x4b\xb4\x84\xb6\x61\x32\xe9\x89\x25\x91\xfa\x81\x44\x01\x4c\xc6\x1c\x82\xd7\x13\x7e\x1f\xea\xe5\xad\x69\xef\xf8\x89\x36\x79\x38\x3b\x55\x32\x53\x77\x9d\x49\x16\x3e\xbd\xba\x42\xef\x2b\xf1\x3c\x94\xba\x18\xa8\x3e\x7a\x2f\xa1\xc0\xb4\xf6\xd4\xf3\xa5\x63\x7c\x49\x17\x55\x54\x17\xb5\x39\xf6\x97\xbd\x36\x77\x58\x0f\xf0\xb6\x7f\x9f\x1f\xd4\xf5\xfd\xbc\xd5\xd5\x73\xaa\x61\xe0\x52\x40\xd6\x58\x03\xe2\xd0\xd5\x27\xac\x40\x6d\xa5\x4f\xd0\x42\xbb\x4f\x8d\xd0\x3c\xdf\xa6\x31\x40\xf6\x72\x09\xc9\x88\x96\x7a\x64\x7f\xe3\x88\x86\x03\x4e\x15\xe1\xf5\xd3\xf2\x32\x1d\x8d\xeb\xe2\xa2\x57\x72\xbb\xba\x62\x9d\x30\x45\x09\xe3\x95\xb5\x97\x1a\x36\x7d\x31\x2d\xb5\x83\x1b\x31\x59\x9c\xf3\xf9\xfc\x96\xa9\x58\xb8\xc6\xfc\x89\x90\x0a\x34\x66\x60\x4a\xc9\x79\x2b\x71\xf8\xb3\x17\x13\x40\x4c\xdb\x88\xb2\x87\xf2\xa1\x64\x4f\x6f\x52\xe3\x97\xbe\xf3\x6c\x66\x08\xcf\xba\x6e\xc5\x17\x80\x3e\x61\xe3\xdc\xb2\xd9\xa8\x02\xd0\x69\x61\xc5\xb2\xa2\x97\xcb\x5b\x9e\x7a\x38\x61\xfb\x18\xbf\xc1\xe7\x22\x81\xd5\xd1\xce\x9e\x8e\xa7\xe0\x5a\x0d\xdf\x68\x57\xb0\x4b\x6d\x24\xc0\x50\x06\x73\xb3\x16\xe9\x17\xf5\x1a\x4f\xdd\xa5\xb2\xcd\x67\x3b\x41\x5a\x7b\x9a\x65\xd3\xad\x35\xbd\x6e\xd4\x46\xa6\x8a\x08\x66\x1e\x21\x87\x0e\x05\x76\x16\x5d\x4c\x2b\x98\x86\xd7\x55\x54\x10\x6a\xb6\x4b\xce\xc2\xf5\x62\xa1\x75\x77\xe2\xef\xcf\xcc\x98\xe5\x40\xb0\xaf\x82\x32\x12\x20\x4a\x9f\x61\xfc\x26\x4c\xc0\x8d\xe7\x73\xc4\x9f\x7d\xf0\x02\x71\xd5\x1b\xe5\x65\xdb\x39\xd1\x64\xe6\xd4\x16\xde\xe6\x12\xc8\xf1\x27\xc5\x6f\xd2\x7d\x08\x93\x26\x6b\xf6\x9a\x67\x02\xb9\xe1\x3c\x75\x87\x37\xf6\x9a\x9b\x75\xb8\xd2\xc4\xf5\x63\xda\x8b\x9e\x9f\x72\x96\x60\xd6\x2f\x8a\xe0\x63\xf8\xe9\x59\xa5\x97\x39\x56\x22\x66\x93\x1f\x61\xad\x5c\x6a\x9e\x8a\x71\xa2\x62\xc2\xb6\x3a\xde\x6f\xae\x4e\x4b\xf9\xbe\xe9\x44\xed\x3a\x43\x77\xfe\xe6\xc8\x49\x83\xbe\x22\x74\x6e\xa5\xbd\x40\xba\x45\xab\x48\xe7\xbb\x1f\x71\x94\xe1\xa7\x0c\xc0\x69\xba\xfa\xec\xae\x4c\xd9\xd6\x8c\x64\x91\xf8\x54\x71\xaa\xcd\x34\x80\x7e\x8d\x41\x85\xc1\xdd\xdb\x3d\xe6\xc3\xb3\xfd\x79\x32\x2e\x8d\x9d\xa4\xa5\x1c\xa8\xb8\xfb\x53\x6f\x59\x79\x3c\x93\xf4\x7f\x7c\xbf\xfc\x6b\xdd\x6e\xff\xf3\xe6\xb6\xd6\x21\xcb\x7e\x7b\x62\x5d\x8b\xc6\x95\xfa\x2c\xae\x93\xd9\x3c\xc5\xb3\xa6\x85\xf9\x98\x15\x50\x27\x75\xa1\xd8\x79\xa7\x37\x98\x45\x63\x35\xa4\x97\xf8\x5a\xc6\x38\xd3\xa3\x51\xe3\xf5\x55\x67\xf2\x3c\x72\x93\x7b\x52\x48\x2f\x25\x0b\x15\x52\xe3\x75\x2c\xf2\xd0\xef\x71\x04\x90\xba\x23\x3d\x97\x82\x51\x89\xf1\xbe\xbf\x03\x59\xdb\xb5\x30\xea\x47\x4b\x9f\xbc\x45\x27\x02\xab\x86\x29\x7d\x9b\xf6\xe9\x7d\x4e\xb6\x61\xec\x75\xf4\xf2\x90\x6c\xb3\x7b\x21\x54\xf1\x26\x90\x16\x10\xdf\x14\x67\x3b\xbe\x7e\x49\x82\x6a\x1c\xfc\xfa\x14\xbf\x63\x13\xb4\x6a\x2e\x09\x7b\x36\x6c\xc7\xb3\xf8\x7a\x7a\x7b\xe7\x4e\xc1\xa7\x57\x45\x64\x8b\x40\x8b\x00\x6a\xa7\xda\x1b\xea\xd9\x91\x3f\x83\xdd\x3b\x62\x58\xd2\x01\xe5\x10\x02\x74\xa3\x38\x75\xd4\x79\xb2\x94\x5a\xc1\x6d\x66\xef\xc3\x0b\x2d\xa9\x97\x33\x23\x2a\x5e\xd5\xb5\x21\x4f\xfb\x4c\x3b\x91\xa7\xfa\xc5\x8a\xb2\x6b\x45\xb4\x47\xf6\xa7\x3b\xc6\x3f\x5f\x95\xe8\x0d\x10\xe9\x5e\x70\x97\xe3\x13\x50\xf7\x5a\x99\x66\x34\x72\x4f\xd3\x69\x1e\x84\x95\x2f\x68\xda\xd9\xe6\x0c\xd8\x74\x84\x88\xdc\xdf\x28\x11\xbc\xe8\x26\xaa\xcb\xfe\x38\xc8\xc1\x3b\x07\x55\x3a\xcd\x7d\xe0\x62\x88\x2c\x1d\x3c\x32\x55\x33\xd1\x9a\xbb\xa9\x81\x54\xbf\x65\x46\x2c\x09\xd0\xd2\x55\x2b\x8a\x0a\x48\x33\x44\xc4\x03\x58\xfa\xaa\xf0\x08\x10\xd3\x57\x17\xcb\x4c\xd3\x95\xce\xd3\xe5\xaa\x15\xed\x5b\x87\xa8\x56\x48\xd5\xd7\x8b\x4e\x42\x47\xf4\x4f\xaa\x84\x77\xc9\x0b\xa4\xa9\xc6\x76\xe9\xec\xd5\xc3\xed\x3d\xf4\xfd\x47\xab\x10\x25\x7b\x43\x70\x12\x49\x69\x02\xb4\x11\x5b\x26\x00\x06\x65\xb4\xe6\x02\xc2\xa0\x38\x32\x94\xfd\x1c\xef\xf4\x42\x2a\xa9\xda\x5d\x6b\x40\x2b\x5c\x92\x3f\xa5\x0d\x43\x42\x11\x51\xfb\x23\x3b\x33\xb7\x92\x77\x8b\x53\xf4\x52\x6d\x59\xa8\x8b\x2a\xc9\xce\xf6\x45\x1f\xf8\x3b\x5b\xcb\x39\x78\xa7\x67\x9a\x3b\xcb\x77\x8f\x05\x32\x12\xb1\x83\x9b\x7d\x7e\x04\x01\x56\xd2\x9a\xf2\xbc\x08\x2f\xda\xeb\x4a\x9e\x6e\xde\xf4\x78\xa1\x7a\xac\x9d\x6d\xcc\x99\x94\xbb\x03\x26\x48\x03\x09\x6a\x0f\x4d\x68\x4f\x5c\x38\xff\x05\xc2\x8c\x4c\xab\xb4\x6b\xbd\x2d\x4d\x79\xcb\x90\x9a\x29\xfa\x83\xac\x34\x01\x1c\x84\x6a\xcf\x42\xb7\x61\x94\x99\xd1\xf3\x78\x94\x16\x6b\xe8\x4a\xd3\x56\xb0\xf0\xd6\xe8\x5c\x11\x66\x71\x2c\x35\x39\xc3\x0d\x44\xbf\xd0\x56\xef\xdf\x83\xe1\x5b\xa6\x32\x96\x99\x69\xe2\x95\x15\xf8\x73\x0e\x5e\xcb\x27\x7d\x7e\x0b\xe6\x84\x34\x7d\x86\x01\xa5\xda\x61\xe5\x40\x32\xca\xe8\x3d\x41\x15\x2d\xad\xa7\xaf\x40\x44\x02\xf7\x32\x36\xea\x78\xf9\x00\x22\xf8\xa6\xd7\xb0\x29\xed\x7d\x9b\xbc\x73\xc3\xab\x99\x93\xd4\x55\xe6\xbb\x88\x15\x8c\x1c\x18\xc6\xe5\x3e\x08\xf0\x53\x89\xf6\xf9\x9d\xa6\x99\xdc\x38\x21\x3a\x1f\x41\x39\xf0\xa7\x7a\x8a\xbf\x56\x6a\x3e\x9f\x9f\xae\x90\x81\x57\x1e\x52\x2f\x95\x36\x84\x16\x96\x7d\xe0\x31\x34\xf4\xe8\xcf\x3f\x6e\x04\x92\x13\x93\xf9\x70\x57\xc6\x2c\x93\xdf\xae\xf1\x33\x7c\x80\x39\x41\xf4\x80\x94\x33\xcf\x1b\x07\xe6\xee\xe2\x6a\x2a\x0f\x8d\x06\xec\x36\x81\x93\xe1\x51\xe5\xda\x49\x81\x39\x3e\xf2\x7c\xfb\x4b\x59\x48\x0f\x72\x2f\x71\x13\x7a\xa9\xb3\x2e\x12\xa1\x32\x16\xf9\x34\x11\xa1\x36\xac\x55\x3c\xe1\xc0\xdc\xbf\x9a\x83\x5f\x39\xf8\xfa\x3e\xbc\xba\xa0\x6f\x91\xb9\x74\x4a\xf1\x44\x84\xc6\x58\x6c\x29\xa9\x10\x8a\x10\x3e\x97\x92\x90\x69\x0e\xcb\x70\x21\x72\x2e\x25\xce\xe9\xd5\x19\x7a\xa8\x1c\x3f\x49\x9c\x0f\x2b\x0f\x1e\xd4\x6c\x1f\x56\xad\x31\x55\x1f\xf4\xa4\xe6\xe4\xb8\xfe\x69\x39\x38\x69\x5c\x03\x69\x8f\x66\xd6\x66\x3a\x95\xd8\xaf\xbf\x07\x9a\xea\xa7\x73\x71\x7b\x3c\x2d\x93\xf7\x7f\xd0\x13\x55\x66\xa5\x5b\xe7\x26\x3e\x99\xe3\x25\x27\x87\x18\x89\x11\xa5\x8e\x16\xa5\xa2\xe6\xdb\x4c\x4e\x17\xbb\xc0\x94\x85\x9e\x95\x45\x9a\x15\xef\x5c\xdc\x72\x68\x49\xae\x18\xe8\x7b\x69\x17\xd6\xea\xe3\x57\x78\xf9\x9b\xa7\x3d\xa2\xaa\x1c\x63\xb1\x1c\xc2\x9c\x99\x6f\xa2\x8f\xfb\xd7\xf3\x10\x7b\x06\x25\xe5\xd2\x4f\x1e\x88\xd0\xf8\xeb\x35\xc3\x5a\xed\xbf\x78\xd2\xfb\x30\xd5\x29\x48\x96\x45\x2c\x39\x29\x0f\x7a\x90\x72\x06\x0d\xaf\x53\x1f\x2d\x4f\x34\xf4\x18\xcd\xb6\xc1\x3c\x38\x99\x60\xc4\x35\x83\x02\x63\x8b\x52\x7d\x78\xa5\x6c\xf2\xa4\x50\xdf\xa3\x07\xd5\x42\x47\x05\x86\x3a\x65\xfe\xb9\x66\x84\x98\xd6\xed\xea\x53\x52\x95\x81\xf1\x89\xc6\x95\x99\xea\xa3\xf9\x87\xfc\x1f\x21\x0c\x0e\x89\x28\x8c\xca\xc2\xf7\x2a\x4b\x2d\xee\xa9\x1c\x6f\x16\x65\xdd\x3c\x6d\x88\xbd\xf3\x63\xd5\xa5\x5b\xae\xe6\xd2\x29\xeb\x22\xee\xc9\x45\x95\x9b\xc5\x22\x35\xbb\x22\x35\x84\x1c\x98\x1b\x1f\xfa\x53\x47\xcc\x86\x58\xa4\x96\x40\xa4\x46\x89\xd7\x6c\x2d\xa7\x1b\x17\x2e\xfb\x9b\x48\x21\xd1\x5c\x7c\xe6\xf3\x90\x76\x29\xca\x3e\x42\xcc\x2c\xac\xb4\xd2\x72\x0c\x4a\x5a\x75\x85\xc5\x9e\xc1\xd5\xc0\x4d\xc7\xc0\x2e\x9c\x8f\x19\xa0\x26\xaa\x36\x8f\xaa\xb6\x20\xa8\x76\xc9\x99\x8f\x92\xd3\x40\x97\x31\x6c\x1f\x31\xec\x02\x54\x6d\xfe\x57\xf8\xcc\xc1\x47\xdc\xee\x76\xc5\xc0\x5f\xe1\x2b\xfe\x11\x9f\xf9\x2f\xf1\xe9\x39\x4d\xae\xf2\xb1\x1d\x10\x37\x45\x77\x0e\xbc\x5b\x79\xe3\x6f\x73\x08\x83\xe9\x17\x0f\xf1\xe0\x8a\x2d\xb1\x28\xf4\x3e\xec\x9e\x4d\x0e\xcc\x57\x78\xa5\x2a\x9f\x37\xee\x29\x98\x5c\x81\x6a\x8f\x92\x33\x1c\x7f\x52\xed\x74\x52\x1d\x67\xba\x38\x9a\x78\x71\x54\xc4\x74\x04\x46\x7b\xc4\xcc\xc5\x36\x26\xd5\x92\x7e\xe0\xbb\x89\xd4\x23\xbe\x42\x65\x58\x9b\xbf\xc2\x67\xfe\x23\xbe\xe2\x5f\xe2\x1b\x56\xda\x15\xe4\x77\x74\x71\xd5\x51\x96\xda\xf4\xd1\x29\x4c\xf1\x03\xf7\xb1\xb7\xcd\xfe\x6c\x34\xd5\x39\x0a\x8d\x44\xe1\x11\xc0\x2e\x28\x89\x6e\xbf\xda\x79\x94\x4b\x80\xde\xd8\xe4\x62\x90\x34\x4d\x9f\x63\xcb\x31\x19\xf7\xf4\x08\x62\x41\x0b\xed\x49\x33\x79\x1d\x83\x3b\xc2\x02\xc3\xa2\x0b\x65\x81\x1e\x6c\xc7\x0d\x46\x1c\xf4\x5f\x05\x3f\x39\x36\x87\x37\x1c\x81\xbe\x58\x60\xe6\x80\xf1\x09\xa4\x19\x49\x62\x1e\xcf\x4b\xa0\x49\xcf\xbe\xe1\xe4\xea\x53\x62\x44\xb5\xf0\x4d\xbc\x81\x91\x20\xcc\xf7\x04\x92\xc0\x7d\x04\xa2\x03\xa4\x98\x17\xb5\xab\x6f\xba\xad\xdf\xef\x83\xae\x9d\x54\x71\x56\x38\x86\x68\xc3\x33\x1c\xe5\x8e\x55\xe6\x88\x83\x60\x6d\x55\xc8\x54\x47\x4c\xd4\x40\xd4\x70\xcc\x01\x29\x29\x3b\x85\x33\x5e\x5f\x89\x8e\x0c\xf2\x02\x23\xda\x74\x16\x97\x74\xbc\x4c\xa0\xc9\xe2\x95\x95\x4a\xcd\xfe\x2a\xf7\x83\x8e\xe1\x6a\xe2\x2c\x33\x5c\x9f\xf9\x82\xd4\xaf\xad\x78\x76\x5d\xbb\xcf\xae\xe1\x33\xad\x4e\x23\x4a\x08\x0c\x11\x53\xe4\x35\x45\x2b\xf7\x2a\x63\x70\x03\xb5\xd3\x25\x45\xdc\x00\xd1\x2b\xe1\xb9\x37\x60\x3d\x76\x5e\x7d\x20\x38\x2a\x05\x0c\xe3\xfe\x82\x47\x3a\x12\x4e\x63\x85\xe2\xde\x98\x41\xb4\x62\x22\xc0\xa0\x40\xc9\x3e\x13\x1f\x51\x44\x15\x8d\x15\x39\xad\x6d\xbd\x90\xa8\x71\x39\xa3\xf5\xce\xc8\xb8\x34\xd8\x89\x6f\x91\xa8\x4c\x6f\x9a\x6a\xbb\xf1\x04\xd9\x20\xff\x24\xa2\x1a\x07\x00\xc3\x34\x46\x35\x5b\x68\xbc\xbf\x9d\x14\x0e\x8b\x24\x81\x17\x2c\x59\x72\xf6\x22\xa9\xc8\xfb\x2e\x04\xe5\x56\xbc\xc9\x91\x7d\x6e\xf8\x59\x07\x49\x3a\x7c\x46\xca\x8c\xb7\xa1\x2e\xc7\xc6\x3b\x4f\x63\x5a\x0c\xb8\xf1\x3a\xb5\xdc\x09\xea\xc5\xb0\xcc\x59\x5f\x4a\x23\x95\xbc\x0a\x7a\x4a\xaa\x2f\x4c\x7f\x2c\xf1\xdc\xa3\x0f\x3f\x64\x79\x14\xe5\x93\xa7\xa7\x9e\xfa\xd1\x4b\xf6\x34\x39\x21\xb2\xec\x4f\x7e\xfb\x18\x42\x67\xa9\x4a\x5d\x7c\x32\x95\x1f\xa7\x12\xd4\xf8\x0f\x4b\x0d\x15\x94\x6e\x20\xdf\x53\x8b\x48\x85\xb9\x18\x9e\xea\x90\x0e\x2a\xdd\xa0\x5f\x29\x24\x5e\x4c\xe5\x16\xcf\x51\xe5\xdb\xf1\xf9\x25\xc8\x05\xcc\xe9\x26\x72\xaf\x46\x09\x5d\x18\xee\x9d\x52\x26\xcd\xbd\x26\x9d\x0e\x75\x26\xbf\xc3\x57\xdb\x62\x30\x12\x05\x10\xc0\x16\x93\x94\xbf\xe4\xdd\x9e\x33\xa3\xc1\x40\x2f\xb7\x73\x0e\x29\xe9\x28\x19\xb2\xcb\xa6\x70\x8e\xd7\x21\x24\x11\x27\x84\x79\x23\xc6\xf5\x65\x53\x4f\x86\xd6\xa9\x9e\xf3\xb1\xe9\x11\x5b\x2a\x62\xbe\xa6\xa4\x71\x8a\xbb\x5b\xf3\x97\x2b\xe9\x14\xca\x5c\xf0\xa6\xad\x79\x8f\x42\x25\x32\x44\x1a\x71\x4d\x1b\x4e\x23\x7e\x7e\xf4\x19\x9d\xb9\xef\x30\x00\xf7\x46\x42\x2b\xcd\x12\x49\x54\x6d\x98\xa0\x3b\x68\xd3\x39\x02\x6e\xd5\xc4\x6a\xe2\x20\x31\x46\xf4\xe4\x44\xbc\x8f\x69\x18\x2e\xe6\x2b\x4c\x9d\x58\x02\x1e\x7b\x72\x16\x31\x82\xba\x35\xb9\xe5\xf7\x26\x50\xce\xf0\x7e\xa6\x58\x1a\xd5\xa2\xe4\xaa\x54\x0d\x01\x11\x36\x94\x63\x8e\xf2\x3a\x6b\x5d\xf0\x54\x48\x96\xa3\xd9\xb6\x98\x74\xe1\x66\x4e\xca\xf8\x27\x7f\x93\xa6\x48\xe6\xbf\x54\x38\x51\xde\x7e\x26\x1b\xd0\xf7\x7b\x5b\x55\xa2\x07\x60\xba\x3b\x3b\x57\x07\x7f\xe5\xb9\xe5\xfb\x0d\xc6\x57\x95\xce\xb1\x1c\x45\x9f\x50\xbc\x9d\xc8\x88\xaf\x1f\x01\xb0\x67\x19\x8a\xa4\x96\xbd\xbf\x57\x65\x3d\x55\x73\xae\xf5\x0d\x9a\x8d\xc2\xe0\xca\x30\x4d\xea\x73\x14\xdc\xc1\xb7\x3e\x26\x6e\xa5\x71\x6b\xc3\x45\xbe\x21\x61\x89\x2c\x0f\xa4\x46\xa4\x31\x95\xba\x87\x9f\x70\x17\x44\x2d\xaf\x55\x02\x86\x0f\xa7\xcb\xc8\x84\x04\xee\x17\xb8\x3b\x2d\x13\xe2\xbd\x1c\xbe\xc0\xc0\xfe\xde\xed\xb5\xb8\xce\xe2\x2a\x42\xac\xf2\xae\xe9\x85\x7b\xb3\x49\x76\xc6\x41\x90\x6b\x24\xc9\x1a\xdc\xbb\xec\x77\xe5\x70\xf7\xa0\x27\x8e\x7b\x55\x23\xf9\xad\x7a\x8b\x1f\x67\xe3\x3a\xf0\x42\x18\xb6\x2c\x60\x61\x29\x6c\x64\x56\x21\x3b\x32\xf1\x9e\xf0\xcb\x32\x2c\x2f\xe5\xd9\x36\x03\x9d\x05\xf4\x44\x23\x9c\xc3\x18\x35\x6c\x3b\x42\x5b\x12\xf2\x68\xdf\x2b\xf4\x46\x71\xcd\x05\x53\xae\x44\xaf\x7b\x39\x75\x9d\x9e\xf7\x9a\xb8\xc9\x02\x48\x0d\xb3\x3e\x79\x70\x7e\x8d\x34\xb3\x90\xc5\xdb\x02\x56\xc6\x55\x6e\xb4\x96\xa4\x5d\x06\x9f\xa0\xd9\xf4\xe1\xa7\x5f\x47\xb0\xa2\x34\xf7\xde\xb3\x27\x35\xa5\xcb\xaa\xf4\xa4\x7b\x9d\xb2\x93\x36\xf1\x8b\xba\xe7\xf4\x01\xd7\x8c\x00\x66\xe6\x54\x49\x6f\xb3\x87\x9f\x6d\x12\xa9\xd3\x93\xad\x61\x22\xad\x80\x57\xab\x71\x8c\xc2\x32\x6a\xaf\x98\x99\x0c\x28\x40\x31\x49\x6d\x3a\x28\x63\x15\x06\x5b\x5b\x1e\x92\x6e\x3f\xcf\x99\x74\xa3\x9f\x3c\x1b\x54\x0a\xf8\x70\xac\x04\x69\x04\x36\x9b\x10\xbb\x79\xaa\xa8\x9d\xf0\x86\x0e\xa7\x11\xce\xa4\xa2\x34\x86\xa8\x2c\x6a\x9e\x99\xb1\x85\x2a\x4e\x69\x0a\x17\xe7\x64\x0e\xcd\xfc\xa6\xa2\x18\x47\x5e\x71\xe8\xc5\xd3\x45\x6d\x55\xcf\x93\xd5\x31\xd9\x3c\xf6\x60\x2d\xb8\xfd\xd3\x62\x6d\x3a\x52\x51\x9e\x1d\x5f\xc1\x73\xd8\x6b\x06\xae\x58\xd4\x59\xa4\x95\x46\x95\xa4\x46\xf7\xb9\xc7\x2d\xe7\x15\x68\x3a\x75\xe1\x7c\x41\x28\xda\x70\xb8\x80\x26\x4c\x88\x3e\xc1\x08\x67\x25\x16\x8d\x66\x03\x66\x8a\x80\x4b\x67\x53\x53\xe9\xbe\x4e\xb6\x23\x45\xa3\x76\xc0\x52\xf9\xa9\x78\x38\xd7\xea\xdd\x89\x43\x38\xb3\x10\xc9\x28\x09\x22\xea\x60\x85\x5c\xaf\xa8\x84\x65\x3c\xc3\xd7\xba\x64\x75\xde\x32\xf7\x82\x34\x85\x28\x5f\xa8\xfc\x99\xa0\x8c\x00\x98\x4e\xa1\x3c\xb1\xb1\x4a\x4c\x09\x3b\x2e\xce\xed\xf2\x48\xf9\xb1\xee\x97\x8e\x78\x29\x0b\x6e\x23\xd1\x6c\x55\x86\x8e\x22\xfd\xf2\x48\xa4\xdc\x3e\xab\x78\xde\xe0\x57\x88\x62\x00\x4d\x61\x65\xd5\x15\xd9\xa5\x60\x1b\xc5\x04\xc0\xf2\x7d\xbf\x48\xf0\x5d\x9b\x81\xac\x97\x59\x48\xb0\x5b\x19\x78\x87\xa2\x96\xa8\x26\x4b\xc6\xa7\xe7\x89\x99\xef\xfd\x7e\xa0\x69\x95\x56\x00\xf0\x31\xd0\xee\xcd\x28\xff\xdc\x4f\x10\xca\xe4\x2f\xf6\xec\xd0\xbf\xd3\x8a\xbf\xd3\x8a\xff\x13\xd2\x8a\xc7\x8d\x5f\xff\x34\xfb\xfc\x33\x0d\x70\xa4\xf1\xc2\xbb\xbc\xf9\x30\x30\xd5\xbe\xf1\x6a\xe1\x32\x26\xef\xfc\x7b\x69\xc5\x0f\x7c\xda\xbf\xc4\xf7\x1f\xa6\x15\xa2\x56\x98\xa2\x56\x18\x90\xca\xff\x4c\x03\x8c\x07\x8d\x9a\x8e\x29\x6a\x5c\x31\x69\x85\x31\x9b\x8e\xc0\x9b\xff\x5e\x5a\xf1\x13\x9f\xf3\x2f\xf1\xfd\xff\x93\x56\x94\xd0\x48\x11\xd2\x9a\x56\x64\xdf\xd3\x8a\xec\xac\x29\xe1\x74\x36\x05\xf5\x0e\x8c\x3a\x2d\xa9\xd2\xa4\x16\x8e\x44\x74\x16\xe8\xfa\xaf\x52\xe4\x14\x31\x7b\xc4\x72\xf1\x9a\x6f\x30\x1a\x9d\x05\x8d\x82\xb1\x38\xd9\x7b\xd1\x45\x3b\x05\x27\xf3\x81\x16\x84\xad\x71\xb8\x25\x36\x90\x7b\x1d\xab\x27\x5c\x58\x4a\x56\xbe\x54\x2e\x34\x48\x22\x5d\x74\x3f\xf2\x89\x02\x15\xd3\xe6\x8c\x87\x55\x3c\x62\x14\xb9\x0c\xf5\xa0\x02\x14\xf6\x74\x5c\xdf\xad\x82\x7d\x3b\x44\xcd\x30\x91\xb3\x5a\x0b\xb7\x13\xad\x9e\xf5\x33\x73\xbe\x73\xcb\x0b\x1b\x9e\x1e\xbe\x07\x06\x0e\x7b\x35\xc0\x42\x70\x17\x95\x89\x1b\x20\x86\xf1\x0e\x7f\x08\xea\x19\xc9\x7d\x0c\x7a\x30\x0b\xaa\xee\x15\x1d\x1f\x27\x7e\x44\x41\x71\x86\x91\x97\xbf\x30\xc8\xe9\x42\xdc\x9f\xd5\xf3\xc6\x5e\xaa\x3b\x7f\x0f\x08\x2f\x44\xb5\xe9\xf2\x66\xd1\x72\x08\x75\xbb\x49\xe0\x59\xe6\x11\x19\xd2\x63\x7d\xd4\x2e\xdd\x29\x9e\x08\x8a\xb7\xee\x2f\xf4\x25\x17\xf9\x83\xc1\x00\x2f\x4d\x06\x69\x3e\x4d\x3c\x0b\xa3\x8e\x55\x25\x23\xf7\xe2\x60\x9a\x99\xfa\x30\x50\xcc\xe2\x7e\xc5\x17\xf5\xf5\xb8\x8a\x65\x46\x00\xcc\x3c\xd3\xdd\xe4\xd7\x17\xbd\x56\x40\x03\xde\xa7\xa2\x58\xc9\x66\x30\x92\x8b\xc3\x9c\x03\x3b\xb7\x30\xe3\x72\x81\x84\x73\xdd\x4b\xb4\x4a\x66\x51\x1e\x48\xd7\x53\x9a\x93\x5a\x64\x69\xdd\xbe\x6c\x5c\xce\x27\xcf\x8c\x97\xc1\xcd\xe3\x4c\x9b\xd0\x29\xb4\x2d\x4d\x50\x9d\xa7\x4b\x72\x53\xf4\x48\xc1\xda\xf2\x99\x77\xc7\x4c\xb1\x12\xbe\x24\x28\xcf\x12\xd6\xc9\x28\xcf\xd3\xc4\xfe\x4d\x8f\x6c\xcc\x17\x21\x65\xcc\x8c\x25\x04\x15\x65\x73\xf7\x46\xbf\x41\x8a\x93\x42\xcc\x09\x26\xa5\x7c\xe4\x69\xd3\x76\x69\xe3\xb2\x44\x82\x6c\x06\xa7\xdb\x53\x69\x02\x2a\x18\x7c\x5c\x81\xc4\x7b\x0b\x46\x08\xdc\xa1\xba\x83\x5f\xe1\xf2\xda\xba\xa4\x42\x37\xef\x11\x64\x5b\xa8\xf6\xee\x9d\x7f\xe5\x91\xd7\x4d\x7c\x8d\xd7\xd3\xe2\x3f\xe1\x65\x29\xd3\xa4\xeb\x9b\xd2\x15\x86\x2e\xe7\x94\xd0\x34\x65\xc1\xa6\xaf\xec\x34\xc1\x22\x20\x97\x6a\xe7\x09\xd9\x55\x7f\x5d\x96\xf6\x7a\x3a\x8f\xcc\x44\xbc\x27\x79\x80\x4d\xa2\x1a\x85\x05\x29\x47\x0a\xc0\x38\x85\x05\x54\xd4\x69\x61\x73\x74\xc1\x14\x71\x30\xd2\x3b\xd7\x02\x11\x0f\xef\x96\xb9\x34\x1e\x48\x87\x61\xf2\x00\x38\x41\x36\x55\x59\x42\xc0\xbb\xed\x8a\x2c\x02\x5f\x69\xb8\xc2\x4e\x54\x64\x18\x43\xe6\xe7\xe0\xc0\x03\xc4\x35\x4e\xa3\xa5\xc6\x69\x93\xa6\x0c\x9d\x79\x33\xed\x12\x3d\x01\x6f\x78\xce\xaf\x29\x09\x17\x03\xb4\xcb\xf6\x85\x97\xe5\xa4\x64\x09\x15\x72\x68\x24\xa8\x6f\xca\x8b\x1f\xca\xe9\xa9\x0c\x7b\x4b\x11\x19\xff\x44\xfb\xb9\xdb\x43\x85\x76\x79\xd2\x81\x69\x5f\x43\x36\x79\xa4\xf9\x08\x2e\x62\x26\x88\x96\x0c\x05\xe3\x7e\xf1\xc2\xe1\x2e\x03\x0c\x93\xd2\xfa\x48\x73\x74\x8b\x89\x4f\xf1\xcf\xbd\xf1\xbd\x6c\xd2\x3f\xb8\x2d\xe1\xbf\xfd\x2a\xa8\x68\x87\x74\x3f\x55\xe5\xff\xf8\x2f\x84\x6d\x87\x74\x37\x55\x65\xdd\xfe\xf2\x2d\xeb\xba\xe7\xff\x0d\x00\xe3\x38\x1e\x47\xe4\xd8\xbc\x53\x00\x06\x41\x70\x05\xfe\xb6\x1b\xf2\x64\x64\x9a\xe9\x97\x6f\xe0\x0e\xdc\x61\x18\xb2\x83\x11\xec\x88\x7c\xfb\x2f\x84\xff\x2f\x84\x8d\x93\x7b\xfb\xb9\x02\x7e\x5e\x3e\x83\x2e\xdb\xdd\xf3\xb2\xfc\xe5\xdb\x7f\xc1\xc8\x7d\xfb\xf7\x6d\x17\xff\xf2\x4d\x85\x11\x6a\x87\x23\x19\x44\x1c\xc9\x01\x02\xb1\x13\x8c\x50\x2e\x8e\x2c\x15\x82\x1d\xf1\x1d\x98\x21\xf8\x11\x89\x88\x23\xb5\x03\x77\x10\x7a\xc4\x8e\xd4\x0e\xa2\x8e\xf8\x0e\x3e\xe2\x2d\x75\x84\x77\xe8\x11\xda\x41\xf0\x11\xda\x11\x47\x28\x80\xd1\x23\x8a\xed\x3e\xed\x4a\x19\xb4\xc3\x8f\xf0\x0e\x02\x57\x38\xf0\x48\x60\x5f\xed\x67\x08\x3a\x92\x9f\x99\x28\x76\xc4\xa9\xaf\x76\x1b\x3a\x7c\x0d\x51\x3b\x18\x3f\x62\xe4\x57\xfb\x19\xfa\x42\x48\xee\x10\xf0\x88\x51\x5f\xed\xd7\xac\x0f\x19\x48\x74\xc0\x8e\x1b\xfa\x03\x04\x1d\xb1\x1d\x7c\x24\x0e\x10\x75\x44\xd6\x8b\x6c\xbd\x82\x5c\x08\x27\xb3\x03\x44\x1c\xb1\xcf\x46\x57\x9c\x18\x14\x20\xe4\x11\x21\x76\x9f\x16\xfc\xe0\x84\x8e\x2b\x31\xc8\x0e\xc2\xbf\x37\x9f\x01\xfc\x48\x1e\x90\x23\xb1\x83\x90\x23\x82\x7e\xb5\x9f\x11\xe4\x88\x1d\xb0\x23\xb9\x83\xa9\x75\xa7\x9f\xf6\x0b\xd9\x81\x58\xf9\x86\x1d\x71\xf2\xab\xdd\xfa\x0f\x6b\x3f\xb1\x83\xe0\xf5\xf5\xe9\x41\x8e\xf8\x01\x3b\x62\x3b\x88\x38\x42\xdf\xdb\xcf\x08\x7e\xa4\x0e\xc8\x11\xdd\xa1\xd0\xca\x91\x4f\xfb\x85\x05\x3c\x52\x07\xe8\x08\x67\x07\x88\x3c\x62\x2e\x04\xa1\xd9\x7a\xb1\x54\x10\x44\x1d\xa9\x03\x06\x0d\x10\x76\x44\xb2\x03\x4a\x1d\x61\x17\x02\xc9\x0c\xc5\x8f\xc8\xda\x87\x66\x87\xf5\xf2\x07\x4f\x48\x17\x47\x32\x9c\x58\x2a\x78\x65\x0b\x01\x1f\xa9\xe8\x48\xee\xf0\x23\xb5\x43\x56\x1e\x40\x47\x6a\x47\x1c\xd1\x1d\x84\xb5\x10\xb8\x52\xb2\xd2\x4e\x1e\xf1\xf5\x22\x40\xe0\x23\x0e\xed\x3e\xed\xd7\xa6\xc1\x2f\x0e\xc2\xe0\x11\x83\xbf\xda\xef\x3c\xc4\x0f\xc8\xba\xcb\x9f\x3b\xff\xe2\x1e\xbc\xaa\x18\x48\x7e\xb5\xe0\x0f\xc9\xa3\xab\x08\xa0\xef\xed\x67\xdf\x47\xe2\x80\xae\x3a\x09\x1f\x49\xe2\xab\xfd\x0c\xc0\x47\xfc\x80\xae\xe8\xf1\x55\x43\x3e\xed\x67\x04\x3b\x42\x2b\x8b\x77\x08\xb6\xbe\x3e\x7d\xe4\x11\x3e\xc0\x47\xb4\x3c\x40\xc8\x11\x3d\xc0\x47\x2c\x20\xa9\x23\x81\xef\x3e\xed\x97\x7e\xa1\xdb\x44\x62\x87\x20\x47\x0c\xfa\x6a\xbf\x86\xc0\x23\xfa\x11\x3b\x7c\x84\xbf\xb7\xdf\xc9\x46\x0e\xe4\xaa\xaf\xab\xa5\x6c\xcd\xa7\x1f\x3e\x6e\x1a\x4b\xec\x60\x7c\x7d\x7d\xd9\x04\x74\x44\x0e\x30\x7c\x44\x77\xab\xd9\x61\x5f\xed\xd7\x18\xbc\xa9\x05\xbe\xc3\xb1\x23\x49\x7d\xb5\x5f\x43\xd8\xaa\xec\x47\x32\x22\x8e\x2b\x27\x57\x7d\x5c\x2d\x88\x3c\xc2\xbb\x75\x2b\x08\x7a\x44\xf1\xdd\xa7\xfd\xb1\x0e\xb5\xc3\x57\xe3\x20\x8f\x30\xf4\xd5\x7e\xb7\x58\x6a\xb7\x5a\x0b\xba\x99\x26\xfc\x9d\xde\x1d\xb2\x8a\x05\x2a\x0f\x10\xbe\x6e\xf3\x88\x47\x07\x68\xdb\xf3\xaa\x90\xc4\xca\x00\xf8\x40\xac\x5b\x42\x8e\x50\x7b\x20\x37\xb1\x20\x2b\x30\xb4\x5e\x04\x28\x72\xa4\x76\x5b\xf3\x43\x5d\xb1\x1d\xb4\x9a\x29\x75\x44\x89\xaf\xf6\xbb\x8e\x93\x3b\xe4\xb8\xd1\x88\x23\x5f\xed\x77\xbb\x20\x76\xe8\x11\x5f\xfd\xd0\xaa\x1d\xe8\x0f\xed\x38\xac\x98\xb0\x23\x1a\x81\x9f\xf1\x23\xbc\x5b\x71\x10\xab\xfa\x21\xed\xba\xa3\xcd\x48\xe1\x1d\x76\x44\xca\xd5\x8b\xed\xe0\x23\x19\xad\xd6\xbd\x83\x3f\x34\xac\x43\xf8\xe6\xb9\xd6\x39\x58\x4b\x7c\x77\x4e\xeb\x05\x0c\x1d\xd1\x00\x81\x36\xef\x00\x7d\xf7\x0e\xab\x04\xd1\x15\x06\x59\xad\x19\x26\xbe\xda\xef\x96\x8e\xee\xa8\x75\x1f\x9b\xe7\x42\x7e\xe5\xbf\xa0\x75\x16\x7e\xc4\x77\xd8\xf6\xfa\xea\x24\x36\xf7\x84\x46\x9b\xfa\xad\xca\xbb\xea\x20\x79\x40\xa0\x23\x7e\x20\x8f\x58\xbb\x7a\x32\x6a\x55\x40\xf4\xb0\xa9\xc1\x6a\x9b\x19\x44\x2e\xdf\x80\xdf\xf3\xee\x28\x4e\x25\x01\xfc\xf1\xee\x08\xb8\x79\x2e\xb4\x24\xd1\x1d\x4a\x1e\xb1\x1d\x89\x1e\xd6\xff\x5d\x9c\x28\x0f\x5f\xd7\x87\xaf\xb1\x81\x22\xfe\x00\x23\x1e\x44\x41\x0c\x7d\x30\x42\x20\xb6\xda\x00\x78\x84\xca\xc3\x6a\xed\xd8\x11\x0e\x20\xf2\x08\x51\xbb\x4f\xfb\x51\x97\xd5\x96\x91\x12\x07\x57\xbf\xb1\x41\xa0\x47\x0c\xdb\x7d\xda\x2f\x1d\x5c\x37\x0d\x6e\x20\x87\x3f\x42\x72\x40\x8e\x88\x02\xc1\xc8\xb6\xdc\x6f\x71\x7c\x18\x07\x2e\xd5\x67\x03\xf0\x77\x82\xf0\x15\x94\x40\x76\x9f\xf6\x03\xba\xfa\x28\x08\x2b\x57\x91\x82\x01\x84\x1d\x31\x62\xf7\x69\x3f\x4b\xc1\xab\xc0\x8f\xf8\xaf\xc9\xf9\x67\x14\x3b\xf2\x88\x1f\x20\xcc\x25\xa8\x23\x15\xc0\xe0\x0e\x06\x7f\x28\xc2\x6a\x7d\xf8\x52\x1d\x20\x0c\x3c\x92\x47\xf4\xb7\xf8\x0f\x5f\xf8\x07\x02\x5c\x87\xd1\x23\xb2\x29\x30\x42\xfe\x44\xbd\x52\xf7\x2b\x7e\xfd\x1e\x85\xeb\x2a\xc3\xe1\xf7\x51\x1c\x3e\xd4\x29\x08\xb9\x7a\x68\xf2\xf8\x47\xa2\xfc\xb5\x72\x40\xeb\xfc\x1d\x4c\x95\xc4\x7a\x62\xa2\xc8\x11\x1d\x48\xfc\x48\x94\x87\x1f\xef\xb7\xab\xc3\x7a\xe5\x12\xf0\x2a\x8b\xaf\x19\xd5\x66\xc2\x48\xf9\x2b\xd5\xf9\x67\x0d\x1b\x0e\xd4\x4f\x15\xfb\x37\x89\xa1\x76\x10\xb2\x1e\x61\x47\x98\x86\xb0\x23\xbe\xf2\x64\x6d\x3f\x0c\xa0\xc8\x1d\xb4\x9e\xc1\xc3\x3a\x1e\xfc\x76\x1c\xc2\x56\x47\x84\x1d\x89\xec\x8f\xc7\xb7\x66\xf8\xdd\xf1\xc3\x8f\xf1\xa5\x02\x77\x38\x7a\xc4\xb2\x1f\x0b\x61\xbb\x4f\xfb\xe5\x6d\x56\xd7\x42\x96\x1b\x2b\x56\x1f\xbb\x5e\xac\x27\xc8\x1f\x80\x1e\xc8\xa5\x22\xd7\x93\x6d\x65\x44\x76\x58\xb5\xf3\x9f\xd6\x06\x0f\xbf\xa1\x0d\x42\x76\x9f\xf6\xa3\x64\xf0\x8e\x38\xe2\xe5\xd7\x42\x88\x0b\xa1\xe4\xaa\x6d\xdb\x5b\x6a\x05\x5f\x0f\xe4\xe3\xf7\x33\x71\x03\xfe\xdd\x4d\x82\x3f\x99\x90\x1d\x71\x17\x27\x8e\xb0\x02\x91\xeb\xa1\x84\x51\x4b\x75\xc0\xa9\x23\x79\x40\xc1\x55\xce\x20\xb8\x86\x5d\x1b\x6e\x62\x23\x85\xf8\x4e\xca\x67\xf7\x47\x28\xfb\x5d\xe6\xec\x3e\x3b\x2e\x0f\xdf\x69\x5d\x54\x74\xf5\xc9\x18\x79\xa4\x3e\x9d\x3b\x72\x0d\x3c\xf0\x23\x92\xfd\x1e\x27\x7e\x4a\xf1\x4b\xcc\xf8\x76\x0a\xe0\x3f\x4f\x81\xf5\x9c\x21\x96\xd5\xb1\x51\x3b\x08\x25\x57\x86\xae\xe8\xe0\xef\xf2\x40\xfe\x99\x1f\xbb\x75\x06\x3e\xfc\xae\x56\x81\xbb\xef\x78\xfe\x40\x43\x41\x12\x09\x31\xf4\xdb\xd6\x71\x68\x9e\x41\x94\x77\xf3\x2f\xdf\xc0\x23\x84\xfd\x83\x09\xad\xa7\xcb\xaa\xf0\xab\x53\xfc\xae\xff\xeb\xbb\xff\x4d\xac\xe0\x77\xac\x14\xb9\x45\x3b\xc8\x91\xfc\x6e\x46\xbb\xdf\xe2\x5c\x73\x81\xf5\x0a\xa4\xff\xdb\x7f\x92\xa4\x54\x79\xfc\xff\xfe\x07\xb3\x8b\x3f\x78\x32\xc8\xef\x64\x38\xff\x4f\x94\x05\xef\x36\xe9\x7e\xe9\xbb\x3b\xf9\x3d\xdd\xc9\xe3\x5f\xbe\x29\xc1\x9c\xbc\xff\x27\xfc\xed\x7f\x3b\xf7\x21\xd6\x6c\x00\xfc\x4a\x7c\xda\x6e\x2e\x93\x2f\xde\x94\x79\x9d\x04\x6f\xf1\x1d\xc4\x79\x52\x77\xdb\x22\x96\x2b\x4a\xdc\xff\x84\xfe\xe7\xb7\x5d\xfa\xd5\xed\xd4\x79\xd7\xfe\xf2\xad\x6f\x93\xb7\xf5\x0c\xa2\xe4\x52\x3b\x6d\xf2\x6d\x37\x41\xbf\x7c\x5b\x93\x82\x6f\xbb\x19\xfa\xe5\x1b\x04\x42\xdf\x76\x13\xfc\xa3\x6b\xbd\x3a\x82\xab\xa4\xbe\xa3\xb1\xdf\x41\xdd\xde\x9b\x77\xf5\xcb\xb7\x2a\xe8\xde\xf9\xf4\x7f\x7d\x82\xa6\x03\xb4\x45\xc0\xf0\x7f\xff\x41\x5f\xf3\xdc\x35\xf7\xfb\xca\x81\x6f\xe0\xb7\xdd\xfa\xfe\x10\x35\x65\xf3\xde\x94\x22\x81\xa3\x38\x41\xbf\x0b\xf7\x1f\x80\x8f\x10\xf1\x5b\x70\x30\x0a\x12\xf8\xf7\xc1\x11\x08\xf9\x0d\x7c\x1c\x46\x60\x1c\xff\x3e\x3c\x8a\xfe\x16\x7f\x0c\x87\x50\xfc\x07\xe4\x60\x04\xf6\x1b\xf8\x88\xa0\xe2\x88\xf8\x7d\x78\x9c\x22\x7f\x03\x1f\x06\x24\x1a\x52\xbf\x0f\x4f\x42\xd4\x6f\xe0\x83\x10\x27\x83\x3f\x80\xa7\x10\xf4\x37\xf0\x54\x84\x62\x14\xf9\xbb\xf0\xd0\x6f\x81\x11\x38\x20\x93\x1f\x86\xf5\x8f\xda\xf3\x2b\x0b\x5e\x8d\x13\xdd\x32\x94\x72\x0d\xf9\xf0\x23\xe1\x52\xd4\x69\x4d\xa9\x32\x14\x5b\xbe\x7d\x59\xf8\xaa\xfe\xff\x05\x23\xdf\x15\xee\xbf\xff\x83\x13\xf8\x77\x50\xfc\xca\x27\xac\xa4\xbe\x9b\x22\xd9\xc8\x24\x49\x18\x21\x91\xef\x5d\x87\x31\x8f\xbb\xec\x97\x6f\xf0\x6f\xf0\x13\x47\x6c\x47\x41\x47\xc8\x25\xd6\x94\x10\x3f\x42\xe5\x9a\xf0\x40\x6b\xba\xb5\x26\x97\xeb\xc5\xda\xeb\x52\x50\x76\x40\x8e\xa4\x4b\x60\x6b\xee\xb3\x39\x4d\x7c\xed\xa1\xca\x03\xba\x3a\x61\xdc\xa5\xa0\x13\xb1\xa6\x91\xf0\x3a\x17\xfc\xe0\x43\x5d\x12\x2c\xd7\x8c\x89\x3c\x92\x19\x76\x44\x15\x74\x8d\xa4\x09\xaa\xfc\xc4\xcc\xd9\x9a\xc2\x95\x6b\x06\x7b\xa0\x8e\xc8\x96\xaf\x22\x47\x64\xc0\xb3\x03\xba\x54\x6b\x94\xbc\x03\x15\x94\xda\x11\xd0\x11\xc9\xd0\x23\xaa\x60\x5b\xd0\x80\x97\xe8\x27\xc4\x25\x32\x74\x0d\x2c\x88\x4f\x1a\x48\x66\x6b\xfe\xf0\x83\xb3\x9f\xda\xc5\xb7\x7f\x65\xe4\xf0\xbf\x67\xe4\x6b\x86\xf4\x31\x72\x0c\x3c\x82\x30\xf2\xb1\xf3\xaf\x5e\xf8\x67\xef\x7f\x64\xe8\x1f\x5f\xf1\xcf\xfa\x86\x23\x28\x05\xfd\x9b\xca\x49\x80\x10\x82\x87\xff\x4b\xe5\xfc\x43\x4e\x20\xff\x26\x27\xa0\x23\x06\x41\x5f\xbc\x80\x8e\x04\x84\x7f\x78\x81\x63\x47\x78\xeb\x87\x7f\xf6\xff\xf5\xb9\xf1\xc3\x0e\xf0\xf5\x70\xc6\xb0\x23\xb6\x66\xab\xc4\xe1\x08\xaf\xda\x78\x38\x22\x5b\x0d\xe0\x88\x1c\x88\x23\x72\xf8\x24\xad\xc8\x1a\x9d\x1f\xa0\x2d\x53\x3f\x12\x16\x4c\xad\x89\xf6\x6a\x34\xf0\x3a\x86\xa3\xd1\x3a\x73\xcb\x71\x91\xc3\x27\x29\x5b\xf3\xbf\xc3\x16\x93\x23\x87\xad\x1c\x84\x1d\xa0\xc3\x1a\xbc\x6c\x69\x3a\x71\xd8\xf0\xad\xab\xae\x70\x6b\xa2\x72\x24\x0f\x47\x6a\x07\x7f\x15\x44\x56\x42\xa0\xe3\x56\x4a\x39\x42\x5b\xa2\x4e\x1c\xf1\xdd\x9a\xb7\x13\x47\xe8\x53\x5a\xc2\x0f\x47\x74\x07\xaf\xd9\x2d\xb6\xc3\xd7\x6c\xfa\x53\x6b\x5b\x73\xc3\xcd\x36\xd6\x0b\x7c\x43\x74\x84\xd7\xbc\xfd\xf0\xa9\x8d\x21\x3b\xb0\x3a\x50\x6b\x54\x83\x1d\x91\xe8\x88\x6d\xdd\xdb\x7e\x77\xd0\x06\xb4\xb1\x81\xf8\x6c\x7f\x45\x0b\x1d\xe1\x03\xbe\x75\xaf\x69\xe6\x6a\x85\xc4\x0e\x5e\xdf\xef\xd0\xdd\x11\x5d\x53\xe0\x75\x2a\xbc\x43\x37\x0a\x88\x6d\x4b\xd8\xa7\x1e\x01\x1f\x89\x0a\xde\x2a\x6f\x19\x74\x84\xa2\x95\x94\x95\x4b\xd0\x07\xdb\x56\x92\xc2\x56\x86\x6c\x15\xbd\x4f\x29\xed\x48\x2d\x15\xb2\xd1\x91\x41\x47\xcc\x45\xc8\x35\xcc\x46\x22\x70\xb7\xb2\x0e\xfd\xda\xc5\x1a\x84\xa3\x3b\x70\xa3\x7e\x9d\x0b\x7e\xb8\xb4\x09\xef\xd7\xf8\xb7\xb9\xc3\x06\xbe\x55\xfb\xd6\xa8\x92\x8a\x7e\x03\xb6\xd5\x2a\x36\x86\x6f\xd5\x81\x0f\x27\x57\x42\x0e\xeb\x0e\xa3\x23\x71\x5c\xb3\xab\x8d\xba\x95\x5d\x6b\xac\x48\x44\x1f\xda\x3f\x52\xc2\x37\x21\x7c\xa6\x6c\x1e\xf4\x08\xad\x14\xe3\x87\x0d\x11\xfa\x21\xf9\x88\x1d\x3f\x53\x3e\xec\x86\xb7\x17\xbe\x6a\xca\x07\x0d\xb5\xee\x65\xd5\x99\x75\x94\x3a\xa2\x2b\xae\x95\x66\x72\x23\x18\xda\xb6\xb8\xd2\x87\xec\xc0\xc3\xea\x6d\x57\xd5\x5c\xc9\xda\xe8\x3d\xac\x44\xae\xbb\xfd\xae\x08\x47\x68\xa9\x60\x72\x55\x3e\x34\x5a\xb7\x8b\x7c\xc4\xbc\xb1\x8a\x3a\xae\xf2\xc4\x3f\x3b\xfa\x43\x52\x90\x8f\xb0\x56\xc4\xdb\xb6\x3e\x65\x91\x0f\xcb\xbf\xc4\xf0\x1d\x84\x5c\xa7\x6d\x9d\x2b\x3b\xb2\xc3\x91\xfa\xac\xf9\x21\x1b\x39\x6c\x0a\x0c\x6d\x45\x43\x6a\xab\x44\x6d\xf5\xad\xad\x5e\xb6\x0e\x6e\x87\xc1\x8a\x67\x3d\x7f\xd6\xb0\x9c\x58\x31\x62\x3b\xe8\xa3\xf9\xe8\x56\x2e\xc0\xb7\x22\x0e\x79\x44\x54\xe4\xab\xc6\x89\x47\x47\xec\xb8\x55\x68\x36\x6d\xdc\x58\xfc\xc5\xa8\x0f\x79\x2b\xb3\x37\x69\x50\x2b\x71\xf0\x47\x58\x2b\x93\x56\xc9\x1e\x3f\x59\x10\x15\x1d\xa9\x0d\x18\xfe\xcc\xd9\x36\xf1\x93\x9f\x9b\x57\xd8\x88\xc5\xbe\xf8\x0b\x7d\xec\x72\xa9\x0e\xd8\x11\x59\x69\xd8\x8e\xbe\xd5\x3f\xac\xe6\xb8\x1a\xe7\xaa\x92\x1f\x31\x63\x3f\x90\x1d\x36\xb9\xc0\x3f\xb0\x6d\x72\x3b\x52\x5b\xef\x87\xc1\xeb\xa1\x0c\x9f\x20\x22\xda\x06\x3e\x72\xf8\x09\x8f\x6e\xeb\xc2\x1f\x34\xc8\x2a\xbd\x0d\xf3\xee\xbb\x8f\xd8\xac\x06\xdd\x41\xd1\x9a\x99\xaf\x02\xda\xaa\x74\xd0\x11\xfd\x4a\xc8\x76\x2b\xec\x4a\x3c\x7c\xdc\xea\x69\xf0\x01\x5d\xa9\xc3\xd6\xd3\xfc\x08\x6d\x15\xb9\x95\x35\xf0\xc7\xd6\x3f\xde\x6e\x65\xed\x66\x27\xab\xb7\x40\x96\x6a\x9d\x40\xfe\x30\x64\xec\x23\x6d\x78\x2b\xa6\x42\xab\xa5\x61\xd1\x67\xf7\x3f\x79\xb1\x31\x69\x73\x11\xd1\x56\x7a\xdc\x28\x47\x3f\xc6\xb6\xad\xb8\x61\x59\x45\x7b\xd8\x10\x7d\xb4\x09\x5d\x59\xba\xda\xc1\xca\xfc\xcf\x7f\xd8\xa6\x46\x5f\xea\xf0\xb1\xbc\x75\x19\x6c\x5b\x06\xdd\x42\x08\xf2\x83\x6e\xa5\x60\x95\x31\xb5\xdb\xdc\xe4\x71\xab\xa1\x6e\xf3\xe1\x1d\xfa\x5d\x69\xb7\xaa\xf0\x66\x36\xe4\xa7\x6c\xf2\xc9\xc4\x57\xaf\x86\x1c\x36\xb7\x8d\x7d\x8c\x90\x3a\x92\xdb\xa7\x19\xd8\xe6\xf8\xf1\x95\xc4\x5f\xd1\x79\xf8\xb1\x5f\xe2\x4b\xc5\x57\xbf\xf9\xd9\x13\x7a\xa4\xaa\x2d\xb5\x45\x36\x4f\x06\x45\xeb\xba\x1f\xaf\x03\x7d\x37\x93\x9f\xce\x69\xdd\x13\x3a\xac\x8e\x6e\xdd\xcd\x07\xdd\xea\x52\xc0\x61\xe3\xeb\x61\x5b\xfa\xc3\xec\x75\xd7\xf0\x52\x11\x9b\x2f\x40\x33\xe8\x53\xf1\xc0\x3e\x6e\xf2\x08\x7d\x94\x71\x53\x48\x6c\xf3\x7a\x07\x68\xc5\xfb\x2b\x12\xd0\xef\x6a\xbd\xfd\xf7\x1b\x97\xb3\xca\x6e\xc5\xf3\xe5\x1e\x3e\xea\x45\xac\x9b\xfe\xda\x19\xf5\xdd\x61\x60\x1b\x2a\xf2\xf0\x1d\xe3\xc6\x5a\xfc\xa3\xd7\x1f\x97\x81\xee\xd6\xc5\xb1\x8f\x07\xc5\x3f\x36\x81\xfc\x2f\xa7\x93\x9f\xe9\xe8\xa2\x42\xd8\x0e\x23\xa2\x5f\x0b\x9f\xd8\x8c\x61\x15\xdf\x46\xf3\xa6\xa4\x1b\xdb\x91\xcd\xb3\x6c\x07\x48\xf4\x91\x09\x7a\x24\x3f\x1c\xfc\x7c\x32\xb5\xb9\xb7\xdd\xe7\xe3\x1a\xe2\xf0\xa5\xbd\xe4\x67\xc6\x87\xd4\xf5\x80\x8d\xa0\xef\xb0\xe4\x17\x2c\xf5\xc3\x95\xa1\xbf\x72\x65\x3f\xfd\xfc\x26\x33\x22\xfa\xee\xe8\x91\x1f\x6e\x87\xdc\x24\xb6\xdb\xc8\xc6\x3f\x27\x1c\xb2\xbe\x5f\xd5\xfe\x3b\xaf\x55\x08\xdf\xe1\xe0\xea\x0c\xbf\xac\x01\x3e\x6c\x1e\x66\x5d\x77\x55\xdb\xcf\xa9\xbf\xfb\x71\x2a\x42\x9f\x10\x21\xda\x24\x7c\x84\xbe\xdc\x16\xb2\xee\xe3\xa7\xfb\x5a\x77\xf7\x75\x3e\x6d\x5e\x7c\x5d\xff\xb3\x95\x23\xf9\xdd\xeb\xad\x47\x13\xf9\x0f\xce\x63\x3b\x51\xbe\xf7\xad\xb6\xb8\x69\xca\xd7\xd1\xb2\xe9\x1c\xf5\x45\x21\xb4\xdb\xb0\xad\x2a\xa8\x42\xd4\x0e\x87\x3f\xea\xb7\x2e\xb7\x1d\x49\xf8\x47\x9c\x1f\x21\x43\x5f\x27\xce\xc7\x47\x7f\x6d\x63\x35\xa6\xd5\x22\x90\xef\x8e\x0e\x39\x7c\x1d\x42\xdf\x0f\xec\x4d\x86\x5f\x4e\xf9\x8b\xdd\xbf\x9b\x3a\x21\x3f\x53\xa7\x3f\x0c\x70\xd1\x7f\x2f\xc0\x5d\x33\x2e\x9c\xfa\x04\xb8\x04\x7a\x84\xc1\xaf\x00\x17\x23\x8f\xc4\xd6\x0f\xff\xf2\x8d\x24\x8e\x04\xf8\x9f\x06\xb8\xbf\xcd\xeb\xef\x54\x72\xbf\xe3\x7f\x90\xa8\x13\xbf\x4d\x8c\xef\x64\x12\xdf\xb1\x3f\x48\xbc\xa1\xdf\x46\xcf\x77\x24\xc1\xef\xbf\x1f\x3d\x1f\x71\x08\xfe\x6d\xe1\x20\x8a\xc3\x24\xfc\xa3\x44\xfd\xb7\xe0\x48\x14\xfd\x51\x9d\x81\xc0\x7e\xa7\x6e\x40\x84\x64\xfc\x07\x75\x00\xf2\x77\xea\x18\x51\x10\x40\xd1\x1f\xd5\x01\x88\xdf\xc6\xff\x61\x44\x92\xe1\x1f\x90\x4f\xc1\xbf\x85\x0f\x12\x3c\x0a\xfe\x08\x1e\xff\x9d\x64\xe4\x8e\xc6\xd4\xef\xc3\xff\x99\x75\x83\xec\x00\x13\x2e\xf4\xfb\x7a\x8f\xfe\xcb\x92\xc1\x3f\xcc\xfe\xdf\xad\x16\x7c\xef\x58\xa9\x7d\x34\x79\xfd\xcb\xb7\x30\x19\x92\xf2\x9f\xca\x8a\xff\x59\x4d\xb1\xf9\xbb\x2a\xf8\x77\x55\xf0\xef\xaa\xe0\x5f\xaa\x2a\xb8\x26\x58\x7f\x5a\x55\x10\xdf\xd2\xbd\x35\xe8\xa3\x8e\x64\x04\x1e\xe0\xdd\x56\xeb\x23\x8e\xd4\xe1\x93\x06\x43\xdf\x43\xac\x2d\xe7\x5a\xc3\x1d\xf2\x13\x77\xad\xc1\xfb\x1a\xd5\x7f\x55\x05\x3e\x69\x21\xbc\x46\x1f\xe4\x0e\xdd\x42\xc4\xdd\x1a\x4a\xad\xc9\x17\xb5\x23\xb6\xcf\xe8\x89\xcf\xdd\x42\xdb\x9d\x07\xc4\x0e\xfd\xdc\xcc\xb3\x23\xb6\x10\x0c\xd9\xa2\x8c\x1d\xb6\x85\xf7\xf8\xee\x93\x22\x6c\xc0\x07\xf4\x33\xf9\xf0\x85\xa4\x5d\x73\x95\x35\x22\x21\x3e\x69\x52\xb4\x45\xa7\xeb\x1f\xfc\x75\xbf\xc2\x07\x18\x5d\x2a\x74\x0b\x58\x22\x70\xab\x83\x60\xbb\x35\x86\xc2\x77\xdb\x6d\x45\xbb\xef\x29\xeb\x1a\x33\x6f\x6d\xbb\x45\xcc\xf8\x56\x1e\x21\xa2\x2d\x8b\xdb\x22\x57\x78\xdb\x3a\xbe\xdd\xd0\x02\x7e\xe2\x5a\xec\xf0\xc9\x6d\xd6\xe4\x03\xda\xa2\x22\xf8\x13\xf8\x6e\xfd\x44\x7b\x40\x76\x47\xfc\xb0\x61\x8d\xbe\xb2\xfc\x2d\x8a\xdf\x6d\x40\xbb\x2d\x2f\x80\x37\xa1\x81\x5b\x85\xf4\xb0\x55\x48\xbf\x8a\xa8\xc4\xdf\x45\xd4\xbf\x8b\xa8\x7f\x17\x51\xff\x2e\xa2\xfe\x5d\x44\xfd\xbb\x88\xfa\x77\x11\xf5\xef\x22\xea\xdf\x45\xd4\xbf\x8b\xa8\x7f\x17\x51\xff\x2e\xa2\xfe\x5d\x44\xfd\xbb\x88\xfa\x77\x11\xf5\xff\xc0\x22\xea\x13\xf9\x4b\x7d\x21\xbd\x9e\x7e\xfe\xa2\x12\x49\x7d\x1e\x41\xfd\x0e\x08\xef\x3a\x3d\xad\x56\xf0\xa5\xd0\x35\xee\x94\xc9\x0b\xcc\xa9\xf0\x19\x53\xd2\xcf\x19\x3a\xbe\x35\x84\x6b\x6f\xa8\xaa\x8b\x3a\x19\x02\xa3\xc3\x4a\x27\x7e\xc4\x78\x1f\x1c\x41\xb4\xa1\x24\x25\x32\x79\xb1\x1a\xdd\x34\xf0\xc2\xd0\x8b\xeb\x18\x0e\x3d\x6d\xd2\x83\x4c\x9c\xa3\x25\x09\xbb\xe5\xbd\x20\x43\x42\x51\x04\x0a\x5e\x4d\xf3\x54\x5c\x6b\x2c\x4a\xc2\x1e\x8d\x4e\xb8\xa5\xfa\x44\x02\x3e\x4c\xfa\xf4\xa6\x22\xe4\x3a\xb5\xee\x10\x25\x55\x15\xce\x2d\x35\xdb\xf8\xbe\x3f\x9d\xc9\x26\xd0\x93\xfb\xfc\x8c\x75\x8e\xc3\xfc\x2a\xc3\x46\x18\x1f\xd5\x82\xcf\x1a\xf2\xdc\x71\x5d\xcf\x5f\x6e\x02\xfb\x1e\x34\x00\xed\xcf\x37\x4d\x3c\x81\x36\x46\x71\x18\xe9\x01\x2c\x4c\x04\x82\x46\x2b\x88\xd7\x65\x55\x3b\x8e\x98\xc8\xce\x1a\xba\xef\x97\x7e\x7f\x51\x3a\xa3\x75\xf4\x49\x37\x26\xfc\xa6\xd2\x8d\xf1\x60\xe8\x91\xb8\xec\x43\xde\x65\x55\xd5\x48\x5f\x73\xda\xee\x15\xa1\x85\xb2\x7d\x2c\xc6\x64\x58\x07\xa0\x51\x79\x17\xea\xa2\xe0\x67\x3f\x1d\xe9\xe1\x22\xdc\x64\xb9\x99\x11\x17\x45\xd9\x54\xbb\x0f\x84\x3f\x91\x8d\x72\xda\x97\x0e\x9f\x0e\x8b\x40\xfa\x71\xb6\xec\x6b\x14\x6a\x6b\x5a\x34\x45\x2c\x75\xf8\x91\x2d\x97\xec\x14\x0f\x5d\x27\x4c\x77\x6d\xf6\x65\x90\xaf\xcf\xcd\x22\xcb\x58\x22\x46\x77\xe8\x75\x6a\x20\xf1\x32\x75\x8f\x51\xda\x3f\xef\x43\x85\xa6\xc0\x15\x7a\x75\xe7\x34\x79\xfb\x3c\x6c\x79\x67\x4b\x52\xa8\xfd\x15\x7c\x14\x60\xc5\x5a\x19\x3d\x71\x5e\x6a\xc8\x69\xa8\x79\xd3\xed\x85\x60\x83\x21\xb3\xb9\x6c\x14\x96\xe3\xc5\x11\xb4\x4f\xa3\x28\x83\x84\x93\xa8\x57\x72\x2f\xa5\x0c\x1b\x47\x38\xfe\x3a\x1b\x27\x55\xa4\xf6\x90\x26\x3d\x9d\xb9\x9c\xa6\x53\xd7\x5f\xf1\x94\xcf\x6d\xa9\xdf\x6b\xe8\xfc\x88\xaf\x69\x37\x83\xb3\x5d\xc5\xda\x43\x58\xa2\x51\x7e\xf8\xa0\xea\x10\xaa\xd2\xed\xa5\x47\x63\x05\x31\x84\x0b\x8d\x34\x21\x21\x40\x83\xdc\x8d\x10\x7c\xaf\x6e\xe3\x27\xfd\x70\x54\xee\xf2\x90\xb0\x45\x4f\xef\x0d\xd3\x9a\x4d\x9c\x65\x62\x76\x3b\xdd\x19\xc6\x01\x6a\x91\x16\xcd\x6e\xba\x4a\x97\x14\x2b\x6d\x58\xeb\xde\x12\x16\x2b\xa0\xc5\x60\xf2\x79\x51\x9a\xb8\x6c\x5e\x5e\x70\xe1\x83\x4e\x17\x97\x4e\x7e\x61\xa9\x88\x58\x18\xa7\x3d\x7a\x5a\xc6\xb4\x87\x7c\xbe\xeb\xbe\x2c\x81\x4d\xc1\x14\x56\x9c\x54\x6c\x6e\xa5\x16\xf0\x2e\x0c\x4d\xb1\x12\xbd\x9b\x98\x07\xaa\x58\xec\x78\x17\x3a\x1e\x2c\xde\xaf\x97\x47\xdc\x5c\xb5\xee\x29\xaf\x54\xbd\x19\x2e\x09\x95\x07\xe3\x85\x46\x72\x5a\x33\x66\x1f\x1f\xae\x13\x8b\x43\x8e\x8f\x42\x8b\x3d\x6b\x91\x9f\xe1\x80\xc1\x6a\x9e\x31\x2c\x39\x16\x9b\x08\x55\x9f\xdc\x17\xc4\x38\x73\xaf\x8a\x34\x6d\xb6\x02\xde\x85\x61\x82\xe6\x32\x07\xbd\x89\x4b\x85\xe5\x02\x13\x57\x57\xc8\x6a\xb9\x7b\xa9\xe4\x3d\x83\xb7\x1e\x05\xee\x69\xda\xe0\x4e\xf4\x95\x88\xaf\xa0\x5f\x2f\xe9\x9f\xfb\x4c\x9b\xea\x89\xfe\xb5\x5c\x07\xf3\xe3\x99\x36\x05\x45\xbd\x41\x88\x76\x26\x82\x7a\xb6\x6f\xfb\xdd\x3f\xdc\x2e\x8c\x92\x20\xac\x6f\x2d\xca\xf9\xe6\xc9\x6a\xd4\x0c\xe7\xd2\x17\x41\xbc\xeb\x3d\x7d\x6f\x68\x60\x2f\xdd\x51\xa6\x29\xf6\x2c\xc8\xde\x27\xd7\xe4\x98\x6c\x2f\xc1\xda\xeb\xb6\xbc\x9f\x16\xc4\xb9\x43\xd8\x39\x88\x75\xd6\xa3\x8a\xb4\xac\xb2\x3d\x97\x49\xd4\xd6\x54\x6c\x13\x48\x7d\x21\x31\x17\x60\xa8\x13\x78\x22\xc8\x8b\x12\x77\x80\xc2\x95\x06\xd4\xab\xfe\x1c\x4a\x74\x2a\x51\x35\x45\x5d\xae\x53\x93\x90\x48\x5d\xe4\x0b\x95\x71\x5c\x90\x20\x08\x78\x1e\x26\x05\x25\x2f\x18\xe4\x4d\x15\x90\xd4\x5a\x27\xeb\xa1\x3b\xd2\x19\xc8\x47\x78\xe1\x3f\xbd\xa0\xa3\xf4\xba\x84\x45\x86\x05\xe1\xd3\xfb\xa1\x62\x3e\x91\xa1\x3a\xb9\x27\x84\x4e\x12\xdc\x33\x4a\x5d\xde\x93\x53\x97\x44\x1f\x49\xf1\x3d\x1b\xf6\x8c\xc4\x0d\xfb\x3b\x13\x3d\x88\x27\xd0\x79\xaa\xfe\x6e\x61\xd3\x73\xed\x11\xbd\x78\xb0\x53\x0b\xf6\xdb\x63\xc3\xd0\x27\xba\xa7\xda\xd2\x10\x22\x70\x16\x47\x5f\x0c\x34\x3d\xf3\xa2\x73\x56\x5a\x50\xd7\x33\x8a\x2d\x78\xab\xd5\xdf\xd5\x34\xf1\x0b\x5c\xbe\x03\xe4\x5d\x3f\xe9\x0e\x11\xf1\x20\x4e\x63\x23\x63\x9e\x55\xa2\x14\x42\x13\x6b\x55\xfb\x78\x5e\xf4\xc6\x63\xde\x86\xcd\x45\x95\x20\x68\x16\x91\x23\xaa\xc9\x2d\x8b\xce\x8e\xc0\x30\x04\x64\x5e\x38\x7b\xf6\x62\x4c\x15\x84\x32\x4c\x36\x9c\xa3\x93\x22\x3e\x45\xdd\xbe\xd0\xe7\x69\x4a\x94\xf0\x6d\xa6\x74\xe1\xf7\x0f\x26\x3e\xa1\x22\xd6\x5c\xcf\x57\xcf\xb9\x42\x94\xaf\xa0\xde\xab\xaf\x69\x55\xc8\xea\x17\xc4\xbc\xae\x7e\x1a\xf8\x90\x4a\x9f\x68\xcb\xb8\xe4\x0e\x85\x2f\xf2\x52\x38\x04\x5e\x8d\x49\x16\x5c\x86\x09\xcf\xa8\x5e\x1d\x08\x59\xd0\x10\xb3\x79\x2a\x68\x63\xd3\x12\x7a\x32\x33\x74\xb4\x4a\x84\xa2\xa6\x32\xd8\x83\xa0\x1f\x9a\xc8\xfc\x96\x16\x95\xb2\x16\xeb\x95\x9e\xcf\x75\x23\x47\x45\x29\xbe\x4f\x20\xc9\x46\xe7\x47\xcd\x74\x8a\xc2\xb6\x16\x2f\x8a\x4f\xeb\x7a\x1e\x4e\x1d\x27\x6b\x8d\x90\x3f\x9f\xed\x19\xec\x4b\xa9\xe5\x38\x87\x65\x69\x5b\x2d\x19\xa3\xd0\xfa\x20\xe3\xe7\xfc\x66\x47\x4a\x5b\x09\x8c\x1c\x18\x53\x70\x29\x30\xc4\x2e\x4f\x89\x5c\xa8\x04\x48\x3f\xe8\xa6\x61\xd3\x8c\xb9\x14\x54\x2b\x77\xd2\xf0\xea\xf4\x97\x85\x0a\x4c\x60\xd6\x67\xcb\xf4\xc8\xee\x01\x73\x97\x0c\x29\x05\x06\x33\x46\xf8\xa6\x09\x32\xa6\x98\x0d\x3e\xa2\xad\xdc\xc1\x69\x4a\x2f\xf3\x98\xc7\xb4\xaa\x01\x54\x2f\xe9\xd6\x2d\x2d\x19\x85\xbb\x60\x82\x80\x54\x26\x87\x8c\x27\x9e\x7a\xb9\xe6\xd0\x9c\xde\xce\xf3\x5e\xef\x1d\xde\x90\x41\x80\xb0\xb2\x6e\x0c\x9b\xd3\x19\x7f\xc4\x27\xd2\xbc\x4d\x16\x8b\x11\x99\xe5\xf2\x76\x48\x24\x18\x00\xf7\xa0\x30\xbd\xf4\xd3\xb9\x19\xf7\x64\x7e\x43\x4b\xdf\x87\x0d\xb1\x47\xf2\x38\x93\xa6\x0b\xe1\x13\x4f\x92\xa6\x47\x5a\x61\xc5\x9b\xcc\xeb\x8c\xc8\xfe\xe9\xae\xe2\xaf\xf5\xac\xdd\x9f\x51\x46\xfb\xe3\x77\x1b\xfb\xd0\x8c\xcb\x57\x55\x3b\x4c\xd8\x04\xa0\x93\x38\x06\x97\x3b\x22\xcb\x42\xfb\x73\xf5\xce\xa6\xc6\xeb\x80\x94\x19\xbc\x73\x4e\xa0\xd2\x1d\xa5\x5d\xd0\x47\x5a\x4d\x16\x40\xdf\x09\x24\xf6\xd5\x48\xf7\x47\xea\x5a\x19\x9f\x8b\x02\xda\x71\x97\xf8\x02\xdc\x2f\xc9\x25\xb0\xe4\x2e\x4f\x30\xf1\xd6\x13\xcf\x65\x41\x12\x20\x22\x96\x4e\x16\xa5\x40\x42\x87\x9a\x7a\xee\x01\x1d\xc9\xd0\x04\x0d\x70\x7d\xc0\xf9\xc6\x60\xb8\x7c\x26\x74\xec\x1d\x41\x3a\xe4\x75\xb8\xa7\x93\x2a\x96\x3c\xbc\x06\x77\xce\xfb\xf8\x1a\xf6\x49\x95\xd8\x62\xfc\x1c\xb4\x38\xd7\x12\xca\x1f\x0c\x25\x41\x99\x1c\xd5\x2b\xfb\x69\x56\xf3\x8b\xac\x08\xe8\xfd\x24\x50\x66\x92\x05\xb8\x1b\xa5\xd3\x40\x37\xfb\x3b\x50\x42\x36\xec\x3f\xc1\x25\x4a\x4e\xf9\x72\xbf\xdc\x02\x60\x32\xeb\x3b\x63\x66\x22\xca\x1a\x2f\xda\xcf\x1b\xe6\x9a\x78\xdc\x4c\x93\x5c\x8e\x27\x39\x14\x25\x1e\x0b\x79\xcc\xf8\xb6\xbd\x93\x7e\x82\x87\x2b\x1e\x45\x0c\xc3\xa8\x12\xce\xb4\x96\xc3\x1b\x4b\x50\x88\x0a\x3e\x31\x60\x37\x3c\x66\x66\x32\xb5\x29\x66\xbb\x08\xf6\xee\xa4\x49\xd9\x73\x70\xb5\xb9\x4b\x0a\xdb\x8f\xbb\x1b\x8f\x78\xf6\x92\x1a\x9e\x62\x60\x71\x2a\x78\xee\x5a\x2a\x27\xa2\x45\x93\xae\x4b\xe0\xc2\x7a\x82\x0d\x67\x26\xcb\xdb\x18\x59\x49\xa2\x91\x46\x3c\xbd\x41\xa0\x92\xd5\x8a\xc7\x90\x57\x03\x23\x57\x74\x3f\x62\xd6\xde\xc0\x9a\xac\x09\x29\x0f\xe9\xd2\x53\x7a\x21\x1d\xc5\xa0\x59\x96\x48\xd5\x89\xaa\x64\x43\x47\x40\xfe\x8a\x57\xfc\xe9\xe9\xe7\xe4\x14\x9d\xf9\x78\x51\xfb\xe8\x71\x2f\xe4\xe8\x6d\xdf\xab\x57\x95\x0b\x3e\x33\xb1\x02\x20\xc5\xfb\x34\x98\xe5\xf3\xd8\x18\x8f\x53\xfc\xa6\xb1\x01\x3d\xc9\x04\xfb\x42\x51\xf9\x71\xd3\xae\xcf\x20\x0d\x5e\x4f\xc2\xa0\xd9\xa2\x05\x4f\xd4\x52\x5f\x11\x1c\xcb\x03\x18\xe5\x96\x86\xe7\x9a\xe5\x72\x0e\x4f\x64\xe2\x76\xa2\x95\x79\x27\x7b\xd4\xde\x41\x54\xb7\x22\xf1\xc2\x95\xa5\xe5\xfb\x80\x2e\x35\xbd\xa2\x32\x82\xb3\x2c\xf7\xa1\xcc\xac\x5a\x3c\x9f\x9c\xb4\x17\x2d\xd8\xea\x8c\x2b\x0d\x99\xa5\xdc\x80\x1e\x86\xd7\xb0\xb7\xc7\x8d\x53\x51\x15\x5c\x50\x4c\x02\x75\x55\xdd\xd7\x75\x96\xf7\x2d\xc0\xbc\xbb\xcc\xbf\x0f\xd7\x05\x72\xd2\xfd\xe2\x70\xd1\x43\xd5\xd5\x0a\xcc\x90\xe7\xc4\x3f\x84\x2a\x40\xd8\x50\xea\xd9\x3e\x26\x1a\x35\x02\x15\x05\xba\xa5\x15\x5f\x3e\xc5\x73\x77\x45\x98\x3d\x84\x9d\x24\x51\x93\xec\xb7\xea\x4b\xe5\xe5\x44\xe4\xa0\x83\x42\xda\x5b\xaa\x4d\x7e\x2e\xfd\xb0\x47\x4d\xec\x65\x84\x06\x13\xd0\x19\x85\xdd\x5d\xf9\xc6\xd6\x4f\x83\xad\x43\x8a\x7b\x5f\x6f\xf3\xdb\xe4\x4d\x0b\xd7\xb8\xc4\x19\xf7\xf3\x29\xf0\x32\xe2\xdd\xa1\x2c\xca\x90\xf3\x9e\x1a\x8a\xb1\x26\x8a\x51\xd6\xcc\x27\xd7\x04\x54\x90\x0b\x32\xe3\xd7\xc2\xde\x8c\x4c\xfe\x65\xc0\x09\x54\x21\x26\xc9\x30\x29\x3d\x53\xc5\x42\xcd\x2d\xcb\xe3\x7f\xf2\x93\xf3\x9a\xf8\xaf\xf5\x93\xaf\x39\xf6\x33\x41\x29\x3e\x3f\xba\x01\x54\x61\x8f\x08\x77\x1e\x92\x4d\xd3\x79\x5e\xfd\x2c\xa1\x15\x8d\x71\x4c\xc7\x9d\x89\x68\xa6\x9c\xe2\x82\xcb\x57\x60\xaf\x84\x1d\x28\xe9\xad\xd0\xe7\x68\xaa\x30\xa1\xf3\x12\x02\xa7\xf7\x78\xdb\x91\x59\x3f\x00\x1f\x16\x36\xdf\xe0\xdb\x05\xc3\x88\x10\x53\x2b\xdb\x7b\xa6\x15\xa7\xd7\xf7\x4b\x44\x3c\x96\x5a\x15\x25\xcd\xd7\x73\x30\x4e\x30\x67\xa8\x9e\x17\x73\x7a\x3e\x78\xa0\x08\xb5\xd7\x15\x04\x31\xce\xed\x49\xfb\x3a\x42\x27\x02\x23\x6f\xf7\x42\x48\xb5\xf4\x5c\x75\xf3\x64\xe9\xe6\xe3\x2c\x3d\x40\xc3\xbe\x02\x26\x97\xfb\xa2\x27\x86\x04\x57\x22\x30\x90\x78\x6f\xb7\x8d\xc1\xd4\x62\x27\xaa\xca\x5f\x2c\xd8\x34\x6c\xfc\xc4\xa9\x14\x33\x80\x0c\xbf\x28\x1a\xd8\xcd\xd8\x5c\x4b\xc5\xb8\xa8\xa3\x33\x66\xb0\x30\xaa\x71\x14\x72\x39\x7b\x33\xbc\xb2\x78\x09\xec\x93\x6f\x74\x1b\x18\xf3\x0c\xf2\x1f\x8a\x54\xd3\x5a\xc4\xed\x01\x27\xa0\xc2\x1e\x19\xcf\xa5\x38\xbc\x99\x1b\x5b\x25\x1d\xbc\xb7\x70\x95\xc7\x52\xb4\x11\xcb\x1b\x45\x03\x12\x01\x7a\x2c\x97\x65\x5c\x32\xe9\x9a\x2d\x54\xed\x78\x66\xc6\xa8\xee\xbd\x42\x20\x71\xd7\xd2\x6e\x93\xdb\x83\x7d\xa1\x58\x62\xcd\x44\xaf\xb2\xd6\xd0\x53\xc3\x1a\x52\x20\xf5\xd2\x40\x28\x4e\xd3\xa8\x97\xd4\x20\x5e\x04\xa6\xd0\x74\x88\x51\x0c\x95\xb2\xcc\xc9\x92\xd3\x57\x52\x99\x6f\x0a\xad\x54\xb9\xe2\x60\x94\xbd\xab\x64\x1d\x12\xf6\xc9\x17\x0d\x4d\x79\xd2\x85\x53\x44\x21\x8e\x9f\x67\x91\x11\x04\xfe\x6a\xba\x0a\x46\xa4\x02\x7f\xc2\x5e\x0f\x52\x99\xc6\x28\x80\x5f\x16\xc2\xdf\x82\x3e\xad\x16\x7a\x84\xd1\xd8\x04\x3c\x23\x1d\xbb\x96\xb5\x98\x87\x2e\xc5\xd7\xd0\x69\x78\xd8\x39\x2b\x4c\xed\x92\x74\x04\x44\xf9\xf5\xd4\xca\x14\x90\x96\x57\xa5\xe6\x70\x19\x1e\x52\xbd\x5d\xda\x4b\x7c\x31\xe2\x7b\x62\x40\x11\x60\x67\x72\x63\xa7\x5c\x4d\xd1\x88\xec\xf0\x1c\x80\xc1\x31\x8a\x4d\x51\x76\x6b\x87\xe6\xcd\xe1\xcc\x1d\xb8\xe1\xe0\x3b\x77\x11\x83\xba\x01\x60\x18\x8a\x0e\xd4\x37\x4f\x5f\x2c\xee\xbc\x69\x19\x88\x1b\xb6\xea\x58\x82\xaf\xf2\xd5\x48\xb4\x59\x59\x8d\xee\x7b\xd7\x19\x8c\x9b\x37\x41\x29\x77\x46\xe5\xf9\x98\x7c\x88\x2d\xd0\x1b\x88\x5f\x12\xfa\x59\xd0\x84\xb0\xe7\xbd\xdc\x85\xdf\x39\x7b\x27\xc9\x7b\x33\x78\x19\x13\x36\xc0\xf0\xd2\x91\x0e\x84\x81\x9b\x5f\x9d\x85\x97\x5d\x2c\x3e\x84\x83\x62\x43\xf5\xbc\x1a\x0a\x32\x99\x99\x80\xf6\x8e\xbd\x4e\xe8\x1d\xb7\xaa\xab\xd9\x72\xc5\xf4\x82\x0e\xa8\xa2\xd2\xf4\xc3\x4c\xab\xcb\xde\x3a\x9f\xf3\x3f\xdd\xa4\xff\x5a\x0f\xc1\x4b\xba\x9f\x3f\xd6\xfa\x80\xa4\x13\xcf\x3b\x40\x4e\xf4\xc4\x0d\x46\x12\xb2\x13\xd3\x3a\x11\x0d\x7d\x44\xb2\x1b\x57\x14\x99\x91\x5b\xfd\xa8\x1a\x26\x1f\x06\x68\xef\xa4\x4f\xb7\x64\xdf\x03\x6f\x64\xfd\xbb\x60\x9b\xeb\x2b\x32\x0c\xb0\xb1\xe9\xc0\x97\xb5\xd7\x79\x4e\x45\x7e\x4c\x4f\xac\xc5\xe0\x72\x5d\x13\x89\x17\xc5\x1e\x20\x56\xf1\xc9\xd5\xaf\xbe\xa0\x23\xe9\x48\x90\x10\x81\x00\x43\x35\xf8\x85\x61\xb4\xf4\xa8\x0d\x51\xf1\xa2\x70\xa7\x9e\x25\x3e\x23\x80\x18\xed\x88\xde\x89\x01\x72\xde\x93\x98\xbe\x0f\x3d\xcb\x43\xd3\x77\x91\x49\x78\x7d\xf6\xf5\x2b\xa1\xbc\xbd\x27\x23\xc3\xfe\x94\x5b\x8d\x95\x65\x3d\xca\xf4\x2f\x48\xd3\x9b\x3b\x97\xbc\xe2\xf7\x0d\xb9\xa1\x51\x49\x70\xe8\x19\x71\x3a\x1a\x73\x67\x97\x2e\xab\x73\xf3\xee\x29\xfa\x0e\xdf\xe8\x27\x54\x46\xac\x81\xd4\xaf\x34\xef\xe5\x2a\xf4\x91\x12\x60\x4e\x7b\xb5\x3e\xa9\x94\xe8\x2a\x3a\x78\x1d\x11\x59\xa3\x11\x84\x35\x1a\xc3\xa8\x15\x12\x41\x85\x07\x81\xea\x8e\x58\xd0\x1a\x2f\x15\xac\x65\xb5\x01\x99\x1a\xaf\xd4\xb7\xa5\x88\x01\x75\xb7\xf5\x18\x04\x22\x45\xa9\x36\x73\xd6\xbd\xb2\xc5\xd3\x14\xe8\x76\xff\xc0\x52\xb9\xa4\xd1\x0e\xa6\xc4\x34\x43\x63\xb0\x03\x51\x41\xee\x28\xdd\x78\x09\xa8\x23\xa4\x7d\x65\xf1\x34\x49\x3f\x93\x80\x2f\xf3\xf2\x1a\xfa\xa6\x3b\x03\x65\x5b\xb7\x80\x06\x19\x4c\x31\x75\xbc\x26\xa0\x8f\x49\x9f\xa2\x34\x62\x20\xf6\xe6\x5e\xde\x83\xda\x25\x32\x26\x19\x5c\x77\x3e\x4b\x62\xb6\xdf\xeb\x91\x47\xe5\xfe\x78\x7d\x78\x32\x42\xec\x07\x1d\xbc\xc6\x7e\x01\x9e\x3a\x8a\x7a\x74\x1e\x79\x9e\xc7\xab\x50\x18\x6c\x36\xa2\x5d\xb4\x8f\x6e\xd1\x50\x0a\xc4\x5b\x5d\x92\x7d\x1f\x86\x93\x86\x82\x77\x35\x28\x4d\x95\xd3\x01\xbc\x1b\x83\xdc\x49\x64\x62\x2c\x6f\xa0\xcd\x81\x01\x96\x29\xf6\x75\x6a\x56\xdb\x95\xe5\xe7\xfb\x75\x92\xcf\x6d\x69\xb7\x33\x0c\x52\x2d\x3c\xd6\xaa\xc0\xd8\xbe\x76\x7b\x44\x40\xa3\x74\x54\xaa\x0f\xca\x65\xda\x67\x93\x7b\x96\x64\x0b\xf6\xaf\xd8\x93\x0d\xad\xf9\x6c\x8b\xaa\x4c\x10\xd8\x85\x74\x67\x66\xe4\xce\x31\xac\xd8\x5c\x09\x78\x58\x4e\x0e\x88\x45\x68\xee\x48\x0d\xe7\x10\x83\x3a\xc9\xe6\x78\x67\xe4\x45\x5a\x63\x27\x18\x78\x7b\x3c\x2f\x08\x7f\xe6\x13\xed\x9b\xb8\xfb\x6b\x99\xdd\xf3\x87\xd9\x15\x0b\x24\x49\x10\x6f\x4c\xc0\x9e\x60\x03\xfc\x5c\xbc\x66\x3f\x3f\x93\x91\xcc\x3f\x69\x23\x64\x0c\x81\xab\xc0\xd6\xbd\xb4\x02\x63\x51\x63\x87\xc9\x17\x3b\xe5\x45\xac\x1b\x27\xb7\xbc\xed\x3d\xbe\x96\xb5\x5c\x4a\x33\x5f\x9e\x26\xac\x1e\xf9\xa7\x24\x79\x41\x6e\xd1\xa9\x2c\x56\x6a\x0e\xc6\x30\xd2\x93\x7b\xc4\x26\x2e\xc1\xed\xcc\xab\x8a\x48\x55\x95\x5e\x6b\xc0\x08\x0d\x8c\xd3\x3c\x15\x5d\xd3\x32\xf3\xea\x9d\x2e\x33\x97\x82\xf5\x44\xc2\x76\x7e\xee\x6e\x7a\xa9\xbb\x8d\xf6\xbc\x77\x11\x1c\xd9\x4d\x17\x9d\xba\x69\x02\xf1\x22\xf6\x9e\x96\x01\x30\xc3\x22\xf3\xd6\x6d\x91\xb8\x8a\x5e\xf0\x79\xaf\x35\x8f\xcb\xe3\xc9\xa9\xb7\xfc\x65\xea\x52\xaa\x35\xc2\x7c\x55\x49\xee\x2d\x3b\x2e\x11\x4c\x97\x7d\x1a\x3d\xd1\x94\xa0\x97\xea\xd5\xd3\xb1\xab\xbd\x2e\xa9\x02\x2f\xb0\x84\xe6\x31\xc4\x80\x63\x9a\xcc\xe9\x65\xee\x80\xb7\xa2\x60\x61\xaf\x8c\xb4\xc4\xa5\x34\x15\xfb\x7b\x65\xcf\x15\x3d\x67\x5c\xd8\x77\xa1\xa6\x4c\x6b\xa6\x65\xa4\x5e\x5e\xb4\x38\x4a\x6d\xa7\xa6\x24\x5d\x88\x6d\x7f\x53\x35\x47\x35\xd5\x42\x79\xf1\x7b\x43\x2c\x9b\xb4\x1c\x4a\x9a\xe8\xa5\x0b\x2d\x0f\xb7\xe0\x61\x82\xaf\x73\xe1\x3c\x00\xef\x94\x80\x8c\x2d\x45\xa5\x2b\xcb\xe5\xfb\x2e\xb7\x0f\xea\x45\x93\x29\x8d\x8f\x2f\xeb\xbc\xe8\x81\x57\xbe\x89\x62\x06\x80\x2e\x56\x78\xe7\x1e\x8c\x2d\xf3\xe0\x27\x47\x10\xdd\x6b\x68\x13\xf4\x64\x05\x28\x7c\x82\x15\xf5\x7e\xe1\xaa\x21\x46\x46\x39\x24\x4c\x5a\x55\xfc\x51\x25\xeb\xae\x25\xa7\x33\xf0\xe4\x13\x02\x40\xf4\x4a\x87\x13\x71\x40\xb8\x3d\xd5\xb7\x21\x82\x5d\xc1\x50\xd2\x1a\x9a\x30\xab\x87\x67\x9d\xda\x13\x78\xc7\x6e\x40\xe5\x58\x37\x50\x7a\xc3\xe7\xaa\x65\x3a\x8e\x04\x5b\x12\x78\x8b\xf3\x72\x6d\x15\xc1\xe6\xb0\xd9\x31\xd8\xf0\xee\x30\xa7\x92\x8a\x11\x52\x19\x8a\x98\xb3\x3d\xa9\x3f\xb9\x4c\x03\x16\xfb\x30\xec\x40\xfc\x75\xd9\xcf\xb4\x2e\x7a\x63\x02\x44\x34\x3a\x5e\x28\x5d\x43\xd1\x87\xcc\x89\x04\x28\x36\x7d\x2a\x2d\x39\xdc\x19\x20\x58\xb5\x04\x80\x94\xcf\xb1\x66\x98\xf4\x71\x43\x08\xb9\x88\x21\x2b\xcb\x3a\xcc\x5b\x18\x49\x28\x81\xfe\x2e\x74\x75\x6e\x03\xa5\x90\xd2\x3c\xed\x00\x40\x8a\x17\x43\x2c\x32\xea\x9f\xfa\x7c\xb6\xa6\xfb\x6b\xfd\xd6\x72\x74\xfe\x69\x76\x6d\x3b\xd0\x10\xef\x4c\xef\xfd\xed\x51\xc4\xe1\xfb\x2e\xc8\x2e\x07\xc1\xfc\xdb\xb7\x4c\x5e\xf1\xe1\x7b\x71\xda\x33\x6a\xab\x44\x46\x60\x8d\xed\xdb\x5a\x6e\x39\x4a\xf0\x8f\x33\x6f\x14\x7c\xe6\x17\x42\x99\xf9\x96\xdb\x09\xcf\xf8\x75\x79\x3d\x0b\x02\x22\x4a\xe4\x21\xdf\xaa\x9c\xdd\x63\xd5\xad\x5c\x06\xa0\x25\x28\x6c\x5c\xd8\x3e\x8a\x8c\x3a\x5a\x10\x3f\x31\x99\x07\x2a\x9f\x16\x10\x30\xdf\x97\x5b\x02\x6b\xed\x4d\xd7\x61\xb0\x81\x31\x6c\x31\x10\x9e\x9e\x16\x9e\x66\xf7\x78\xbf\xd8\x23\x84\x88\xa8\x2d\x18\x74\x50\xd0\x00\x7b\xed\x24\x3f\xf4\x41\x99\xb9\xbc\x27\x42\x1a\x46\xce\x78\x95\x27\x17\x6a\x10\x7f\x92\xed\xcb\x30\xd3\xce\x70\x37\xd8\xfb\xab\xa2\x91\x04\xcd\x8b\xd9\x02\x16\x93\x96\x87\x4b\xd3\x11\x49\x63\x9d\xf8\xf4\x26\x9d\xde\xec\xdd\xa0\xef\xcc\x8b\x09\x64\xc3\xe0\x64\x2b\x32\x68\x7e\x8a\xc9\xa4\x62\x68\x2d\xdd\xc3\x0e\xcc\x0e\x9a\x5a\x14\xa9\xf5\x62\xaa\x37\x3b\x09\x0c\x59\xf5\x8f\xa4\x39\x33\xd7\x91\x7f\xd1\x66\xd4\xb6\xb2\x4d\x9f\x79\xf1\x5d\x05\xe2\xfb\xf1\x92\xa1\x65\xd0\x8a\xfa\x84\x32\xdd\x3c\xc9\x25\xec\x3a\x4f\x73\xaa\x1e\xd8\x75\x3f\x11\xc8\x8b\xa2\xf9\xe0\xf6\x36\x01\x8d\x83\xf8\x73\xd9\x4b\x4f\x0b\xc9\xa9\xb3\x91\xd3\xfb\x60\x9f\x59\x2f\xf2\x34\x9e\x1f\x76\xab\xbc\xcd\xe0\x9a\x77\xba\xcd\x5e\xca\x8c\xbf\xd5\x98\x46\x60\xad\x0a\xbd\xf2\xb4\x2a\xb5\x7d\xcc\x20\xfd\x7e\x6f\x04\x0d\x76\x45\xed\x2e\xe4\x3d\x4f\x6a\xf3\x76\x11\x15\x54\xa7\x41\x30\xef\xec\xb6\xc7\xbd\xda\xb8\x36\xa0\xfd\x50\x6d\xfa\xfc\xba\xab\xdc\x04\xbc\x67\xe6\x1c\x05\xee\x62\x69\xd6\x09\xbd\x5f\x41\x63\xff\x2e\xa4\x3b\xf6\x6e\x1f\x66\x9e\xc7\xc4\x3c\x6b\x44\xdf\x78\x16\x72\xab\xc1\x24\xe5\x41\x2d\xbf\x98\xb4\x46\x85\x06\x08\x11\x1c\xa4\xbc\x73\x82\x55\x4a\x1d\xe6\xb9\x37\x62\xde\x09\x16\xc8\xbb\xc5\x85\xc3\xbb\x47\x03\x79\xaa\x70\x81\x99\x4f\xf7\x3a\x15\x32\x8b\x6d\x9a\x13\x3c\xb9\x3a\x7b\x65\xca\x51\x8e\x68\x7a\x64\x3c\xa8\xed\x69\xbc\x4b\xf6\x9b\x62\xfe\x99\x01\x63\xf7\xd7\x0a\x18\xef\xb7\x5f\xff\xba\xff\x9b\x87\x78\x47\xb7\xc8\xa5\x0a\xc2\x73\xcc\xc9\x0c\x9c\x96\xfc\xe8\x53\xfc\x74\xf6\x73\xc6\xe1\x8d\xa7\x0b\x63\xaf\xb4\x63\xbc\x7b\x1a\x3e\xf9\xce\xeb\xfb\x87\x7c\xdf\xd3\xf7\xff\x8f\xbd\xff\xd6\xd5\x18\x69\xb6\x04\xd1\x07\xa2\x41\xad\x4c\x6a\xad\x35\x3d\x6a\xad\x3e\x6a\x3e\xfd\x45\xfd\x75\xee\xa9\x6a\x60\x06\xa7\x07\x53\x03\x94\xd1\x06\x8d\xbd\xc1\x6f\x31\x91\x99\x11\xb1\x22\xb8\x22\x29\x68\x6e\x59\x5a\xa5\x25\xc9\xdc\x98\x27\x21\x77\xbd\x5a\x94\x75\xbd\x8f\x4c\x6d\xbf\xb6\x03\xe9\x95\xa4\x51\x91\x44\x6a\x99\x2b\x24\xec\x1d\x9b\x44\xb9\x75\xd5\x15\x45\x01\x04\xdd\xca\x96\xc5\x08\x74\x8d\x7e\x7e\x38\xf3\x9a\x29\x5f\xed\xb8\xd7\x9b\x7d\x83\x3f\x03\x5a\xae\x37\xda\x5d\xb1\x8c\x55\x61\xe5\x95\xd7\x9d\xbd\x31\xfc\x20\xcd\x1b\xa6\x2b\xcb\x33\xb5\x8a\x3d\x95\x15\xda\x86\x51\x3f\x9f\x37\xdf\x7c\x3a\x82\xd9\xc3\xed\xa9\x01\xc7\x9f\x09\x91\x32\x6e\x1a\x60\x0d\xa3\xe2\x62\x34\x6b\xcc\x7b\x67\xdb\x29\x9d\x86\x3a\x1d\xa1\x07\x67\x13\x93\x22\x93\x67\xb6\xbd\xab\x5b\xad\xc8\xb2\xc6\x79\xc7\xe6\xee\x71\x28\xda\xce\x99\x36\x3c\xcd\xb2\x4f\xdf\x0d\x5e\xe7\x6e\x18\xcc\x30\x43\xc3\x39\xec\x17\xd6\x10\xc0\x46\x02\x1b\x93\x12\x3b\x41\x4f\x23\xcb\xc1\x36\xc0\x41\xce\x9e\x42\xa1\xbc\xe5\xf7\x72\xe9\x68\x29\x74\x22\x48\x27\xff\xdc\xe5\xc9\x71\xdd\xe1\xa1\x71\x8b\x5e\x1d\x97\x62\xfd\xaf\xd8\x30\x5b\x25\x78\x5d\x2e\x09\xf2\xe8\x8f\x93\x61\xe2\x2e\xc7\xb1\x92\xb3\x43\xa1\x76\xf0\x58\x29\xba\x01\x84\x40\xa4\xe3\x2b\x2b\xf9\xd0\xa2\xe2\x9e\x5f\xb7\x1b\x1d\x0d\x61\x2f\x14\x77\x86\x23\xd6\x03\x4b\x8e\x0d\xf1\x88\xf2\x2d\x3e\xc2\x16\x18\x21\x94\xcd\x81\xc9\xea\x91\x36\x51\x4f\x89\x76\xd8\xc7\x46\xd6\x37\x31\xde\x03\x05\x7b\x17\x51\x28\x3c\x31\x38\x1d\xf7\x13\xd0\x92\x32\x67\xbd\x4d\x79\xc6\xf2\xa6\x66\xc7\xc7\x90\xf6\x52\xbd\xb4\x33\xc7\xbd\x7f\x2e\x21\x0f\xf6\xe0\xee\x16\x13\x6f\x45\x7a\xb3\xcd\x3a\x87\x33\xc8\x7d\x7b\x3e\x60\xcf\x94\x4f\x20\xf4\x98\xfd\x61\x2b\x08\x0d\xe7\xf7\x49\xc7\x0c\x79\x15\x2f\x3a\x21\x40\xe3\x67\x81\x0b\x63\x47\xfb\x1b\x68\x36\xce\xf6\xbc\xec\xac\xde\xab\xd0\x79\xb2\xd7\xfb\xdd\xa1\xc7\xeb\x40\x79\xcd\xf9\x12\xcd\x15\x87\x23\xca\x07\xdc\xd0\x34\x77\x73\xb0\xa7\x58\xa1\x43\xed\x05\x2f\x7c\x75\x95\x15\x9a\x63\x4d\x5e\xc8\x00\x40\x7a\x79\xd6\xa4\xff\x73\xd2\xe8\x5d\xf3\x23\x17\x06\x4e\x66\x32\xff\x70\x24\xfb\x77\x11\xc8\x52\xfc\xcb\x0c\x29\xfa\x07\x21\x4c\x52\xaf\x2a\xd4\x85\x13\x29\x6c\x6d\x68\x3d\x37\x59\xf2\xac\x50\xae\x1d\x27\xc0\xee\x22\xa4\x6e\x59\x5e\x41\x93\x2b\xd5\x03\xba\x3b\x59\x55\xed\xba\xbe\x22\xa6\x5b\x9f\x73\x62\xc6\x73\x27\x2b\x24\x37\x5e\xab\x9c\xf7\x1d\x84\x1e\x17\x1e\x23\xb4\xc3\x68\x56\x8f\x80\xf7\x7d\xc5\xfa\xa6\xc9\xf4\x8a\x24\x56\x99\x38\x85\x82\x3b\x60\x5b\x80\xed\x09\x8a\x52\xa9\x69\xf9\x3b\x9c\x50\x81\x69\xae\x99\x06\xd0\x6e\x51\x3a\x5f\xc7\x31\xde\x28\xa4\x21\xf7\x46\x7f\xc2\xe2\xd5\xcc\x74\x55\x1e\x2a\xe8\xf1\x13\xff\xbc\xbe\xa0\xa5\xe5\xa2\xd2\xae\xe5\x5c\x8e\xe2\x01\xd2\x9a\x31\xb5\xf8\xaa\x4b\xaa\x7c\xc9\x13\x14\x0e\x2b\x0e\x4d\x3d\x58\x98\xf7\xed\xb8\x83\x3b\x8e\x13\x06\x65\x82\x05\x71\xe4\x10\x61\x82\xba\xfb\x88\xea\x6e\x8e\x07\xe5\xeb\x3b\x0b\xea\xc7\xfe\xe0\x39\xdc\x3f\xea\x51\x52\xa4\xc0\x31\x58\x60\xaa\xfb\x0c\x5c\xec\x0b\x71\x1f\xda\x30\xfa\xd5\x28\xd5\xc7\x8a\xdf\xd8\xbf\x87\xe2\x56\x86\xea\xae\x37\x07\x76\x0e\xc7\x64\x51\x0a\xff\x0a\x05\xc6\xc4\xdf\xe1\x54\xcf\xee\xe5\x84\xe7\xbe\x7b\x8a\x89\x79\x0d\x88\x44\x25\xdf\x8c\x5f\xd0\x8d\x2a\x99\xcc\x84\x77\x9c\xaf\xe3\x33\xa8\x73\xa1\x2b\x31\xbc\xb9\x54\x99\xb4\xc8\xdb\x9b\xc5\x3d\xde\x6c\xce\xe8\x5b\xfc\x72\x15\xb7\x39\xe0\x4c\x4f\xdc\xf1\x16\x52\x15\xb7\x90\x02\xdf\x1a\xcb\x2c\xc8\x6b\x04\x94\x29\x47\x36\x81\x44\x53\x3c\xda\x54\x0b\x79\x0d\x39\x04\xb7\x74\xc1\x5c\x76\x79\x90\x84\x25\xbd\xf0\x33\x1f\x41\x89\xe6\x7d\xf0\x30\x03\x0a\x8c\xc8\x2e\xab\xa0\xd8\x1c\x3f\x1f\x32\x02\xd5\xac\x79\x6f\x82\xf2\xde\x01\x49\x44\xfe\x9e\x67\x01\x4c\x0d\x68\x51\x96\x8c\x5d\xd3\xc2\x82\xdf\xfd\x4e\xce\x61\x28\x43\xe9\xb3\x01\x34\x01\x3b\x6b\x65\xaf\xbe\xcf\x94\x96\x91\xd4\xe4\xf0\xfd\x03\x56\x14\x29\xc7\xf6\x90\xc3\x40\xb0\xd7\x36\x4a\x02\xcc\x94\xc2\xb5\x0d\xee\xe7\x30\xb3\x39\x31\x57\x75\xe8\xc4\xfd\x08\x11\xfe\x63\x8c\x6a\x1d\x69\x66\xf4\x03\xb4\x8b\xf2\x13\x86\x19\x82\xb3\xaa\x1e\x55\xc4\xc8\x7f\xb8\x1c\xb2\xfe\xcb\x2a\x9c\x53\xfb\x57\x85\x13\xfa\x4f\x85\x33\xb1\x7d\x1b\xc5\xb7\xe4\xc9\x22\xc2\x1f\xf9\x6c\x35\xb5\x48\xca\x9b\x05\x11\x07\x91\xfa\x31\x2e\x4b\xfc\xf2\x25\x3e\xf7\x1a\x12\xc1\xf6\xdd\x90\x00\x1b\x7e\xe2\x76\x36\x9b\xc7\x56\x27\xf3\xea\x98\x27\xb8\xec\x7e\xc8\x19\xd4\xb9\xb4\xaa\xa5\x2a\x39\x5d\x27\x60\x40\xc7\x96\x4a\x83\x8c\x3e\x14\x4d\x91\xfd\xc7\xcf\xf3\x84\x88\x9e\xb7\xb5\xd8\xbc\x43\x61\x00\xbf\xb9\xf8\xf5\x04\x89\x45\x19\x7a\x46\x5d\x94\xd7\xbb\xe8\xe4\x40\xff\x93\x7a\x2a\xbe\xf2\x09\x92\xc7\x2b\x09\xdd\xa7\x55\xd7\xdf\x3a\xf9\xa3\x34\x9d\x13\x60\x19\x13\x7e\x9a\x76\x6a\xe6\x47\x3f\xa0\x23\x85\x54\x2f\x05\x00\xd4\x12\x61\xea\x05\xca\xe0\x5d\x32\x18\x4e\x34\xc8\x70\xc9\x34\x2d\xbe\xb2\xd9\x9d\xcc\x87\x94\x77\x3d\xe6\x26\x95\x44\xd4\x67\x68\xb8\xb4\x80\x9c\x51\x3b\x03\xd3\xae\xd2\xfe\x3a\x8d\xcb\x1d\xe3\x2a\x60\xbd\x12\xe8\x2f\x47\xd7\xf2\x77\x92\x86\x6d\x0b\x23\x88\x77\x39\x11\x59\x02\xa4\xaa\xa6\xdb\xc9\x72\x43\xf4\x14\x31\x19\xfd\x0d\x22\x8d\x84\xe5\x43\x9e\x60\x76\x84\x25\x3d\xd2\x13\xd8\x3e\x30\xb8\xe8\xcb\x65\x26\x18\x76\xc7\xa8\xfb\x77\xc0\xbb\x06\x95\xd8\x7e\xaa\x53\x82\x0d\x10\xa0\xf0\xbc\xe4\xd6\xdb\xd4\x42\x27\xde\x54\xbd\x53\x00\xb5\x44\x55\x09\xa7\x64\xad\xeb\x70\x42\xdd\x38\xb3\x72\xb6\xc2\xd0\x1c\x96\x29\x00\xa5\xf4\x24\x8f\xc0\xf7\x30\xdf\x76\xc2\x5b\xa4\x00\x9c\xc4\x65\xb0\xca\xdc\xe6\x1b\xaa\x92\xbc\x82\xe0\xe1\x59\x1c\x3b\x7b\x87\x0c\xc9\x28\x09\x5d\x86\x4b\x87\x1c\x6a\x33\x90\x4d\x36\x5b\x71\xe7\x61\x37\xb5\xce\xe8\xf6\x19\x9e\xc0\xc3\x87\xf6\x8d\x08\xce\x2b\x0a\xbd\xcc\x37\x6d\xbe\x26\xe6\x04\xbf\x5a\x18\xce\x49\xef\x5b\xd5\xaf\x5a\x67\x4c\x20\x62\x67\xd2\x25\xcf\x1e\xec\xc1\x8a\x23\xc6\x37\x3c\xbe\xe8\x1d\x61\x60\xb2\xcd\x3a\x09\xa0\x03\x7f\x45\xc1\xe8\x87\xa8\xe3\xa8\xae\xa0\x3f\xc8\xdc\xe0\x94\xc7\x40\x23\x4e\xd5\x2c\x4a\xc4\xea\x07\xd8\x71\xa7\x16\xc4\x8e\x2a\x42\x93\xa0\xc0\x69\x27\xa9\xec\x33\x05\x23\x1b\x00\xef\x0b\x54\x33\x1b\x30\xe7\xbd\x19\x77\x8e\x17\x20\xfd\xdc\x97\x3a\x93\x57\x18\x8b\x13\x8b\xeb\x56\x0f\xd7\x61\x35\x8f\x19\xe4\x25\x06\x0f\x4e\x28\xcb\x45\x19\x25\xa2\xf9\xfb\xb8\xec\x8d\x98\x61\x4a\xd4\x2b\xaa\xb8\xa1\xce\x69\xef\x4e\x00\x93\xcf\xbd\xc5\x7a\xb0\x3c\xd9\x54\x91\xfa\xa5\x5b\xe8\xba\x71\x08\xca\xed\x17\x1d\x81\x37\x45\xf7\x14\x8d\x90\x3b\x99\xd8\x45\x12\x56\xb0\x49\x8c\xf7\x9b\x0c\x6b\x98\x0f\x4f\x16\x29\xc3\xda\x69\x1c\x2b\x7d\x88\x8a\x10\x8c\xba\xbf\x64\x57\x79\xeb\xec\x5d\x96\xc9\xb6\xad\x1b\xfc\xd5\x5d\xc0\x6d\x2b\x21\xb0\xbc\x68\xb2\x40\xf5\xec\xa0\x6b\xc6\x49\x18\xec\xa3\xf2\x98\x9e\xfd\x3d\xa7\xfe\xd1\xa8\xbb\xb6\xff\xae\xfc\xb1\x35\xff\xca\x1f\xc7\xe3\x27\x40\x42\xf0\x80\x60\x9a\xf3\x59\x6c\xfe\xae\xf4\x2b\x95\x21\x4f\xac\x58\x6a\x9e\xc4\x19\x39\x0d\x51\x94\x84\x10\xce\xfa\x91\x4a\x96\x62\x2e\x0c\x63\x4a\x97\x62\x6c\x0c\x53\x2d\x9b\x75\x01\xa1\x59\x20\x9b\x1b\x03\xcd\xf7\x63\xc7\x9b\x06\x3f\x39\xac\x61\x3a\x73\x4f\xfd\x39\x70\x85\xca\xc8\xab\x7a\x82\x6a\x2a\xfc\x8e\xda\x93\x0d\xd4\x14\xbd\xbe\x69\x51\x4e\x08\x5f\x94\xd1\x35\x93\xfa\x37\x3c\xa2\x3c\x71\xca\x2f\x23\xe7\x89\x3e\xc7\x86\x7a\xf5\x14\xa2\xdf\xd8\x32\x71\x9c\x6f\xfa\x03\xb6\x0d\xa4\xb3\x77\x08\xc8\x22\xb0\xfe\x95\x2d\x95\x7f\x21\x02\x7a\x97\xc3\xce\x9c\xde\x09\x5b\x21\x3e\xba\xe6\x79\x4b\x39\xfe\x02\x7a\xac\x3a\xc9\xee\xda\xa8\xb2\xd9\xa1\xa9\x84\xd4\x22\xbc\x96\x43\x4a\x8e\x49\xcd\xb3\x26\x18\x3e\x07\xc6\xd2\xc1\xed\xc0\x7e\x30\x96\x13\x8b\x26\xae\xcb\x7b\xc3\xec\x16\xe6\x8f\x12\xe7\xd2\x0e\x33\x6f\xd2\x73\x3a\xa3\xe4\xe2\x61\x24\xde\x50\x79\x41\x87\x8d\x9a\x22\x00\xde\x07\x8c\x77\x5d\x43\x8a\x52\x9e\xcb\x6d\xd4\xc0\x31\x7d\x64\xd0\x5a\x55\x8b\xac\xe7\x3d\x4a\xd0\x0f\x4c\x98\x0d\x68\x20\x7f\x92\xd7\x25\x90\x91\x8b\xc5\xed\xb8\xa3\x5c\x9e\x16\x17\x18\xca\x98\x89\x57\xfd\x26\x7a\x95\xd3\x3a\xd7\x49\x43\xa9\xdf\x6e\x17\xd6\xb5\xa9\x16\x8a\xc6\x91\x70\xdd\xba\xba\x4f\xda\x23\xbb\xa1\x70\xd7\xa0\xa1\x45\x23\xf8\x06\x46\x4d\x4d\xca\xb8\x44\x26\xf5\xbb\x81\xdd\x86\x78\xc2\x96\x9d\x29\x39\x3f\xc9\x6c\x38\xb7\x33\xd2\x90\x81\x49\xc5\x09\x31\x4b\xc9\x7c\x85\xca\x4f\x19\x64\x54\x43\x2c\x21\xc4\x1f\x56\x08\xb7\x2d\xac\x9f\xa3\xab\xc0\x49\x81\x67\x14\xf3\x20\x4f\x38\xa6\xec\x9c\xd6\x1a\x05\xd0\x9f\xfc\x42\x0b\xd1\xa5\x9e\xfe\x21\x18\x07\xc8\x01\xff\xd9\xc1\x4d\xa7\xb5\xca\x1e\xbb\x16\xe1\x0c\x96\xdb\x68\xa4\x6d\x90\xed\x3b\x60\x66\x09\x49\x19\x4f\x9e\xb2\x2d\xb7\x56\xfe\xdc\xbc\x29\x56\xb1\xda\xca\x60\x1d\xd7\xcb\x89\x30\xb1\x9d\x98\xee\x49\xc1\xfd\xde\x31\x76\x89\x38\x03\xdc\xa6\x5d\xc0\xe3\x4d\x40\x4b\xde\xe1\x7e\x9b\xc4\x24\x51\x59\xf5\x5b\xda\x68\x84\x14\xf0\x14\xa0\x84\x74\xd8\xb4\xac\x68\xc2\x6e\xaa\x5e\xe8\xee\xe3\x65\xc7\xde\x1c\x8c\x37\x73\xd1\x34\x9c\xad\x6a\x22\x14\x71\xb6\x49\x95\xe7\x8c\xe3\xbd\x53\x86\xeb\x87\x26\xf3\x48\x8f\x15\xc3\x38\x8c\xda\x76\x52\x76\xf0\x34\x63\xfd\xc3\x52\x87\x75\xfe\x77\x49\x1d\xa6\xe3\x2f\xa9\x03\x7d\x58\x7f\xe4\xaa\x71\x6c\xaf\x10\xc7\x04\xd1\xa4\xe6\x1c\x84\x3d\x2c\x63\x9a\xbe\x08\x0c\x5a\x2b\x51\xb5\xc2\x13\xd9\xa6\x83\x8d\x2d\xf4\xb4\x00\x8d\x4a\x4d\xf0\x3d\x0a\xc9\x3a\x84\xde\x8f\x73\x84\x0a\x07\x39\xda\x2f\x7a\x4c\x09\xe6\x07\x3a\x45\xac\x1e\xfe\x9e\x19\x9e\xa0\x45\x49\xfd\x59\x79\x53\x0a\xac\x2a\x00\x81\xe1\x0f\x97\xf7\x09\xca\x93\x06\xa1\x6b\x5d\x5a\x9f\x48\x51\x23\x36\x91\x3c\x5c\x61\xa8\xb9\xd0\x5a\x9f\x8e\xae\x1a\x4b\xb6\xf5\x77\x9c\xc0\x8d\x6e\x14\x1e\x93\x35\xed\x3c\x7b\xc5\x83\xeb\x94\x1a\xe9\xfe\x98\x74\x3d\x17\xb8\x6a\xde\x10\xc3\x49\xd2\x45\x1c\xb6\x77\xbd\x97\xc0\x6b\xc2\x12\xa5\x78\x42\x59\xb2\x6c\xe5\xda\x7a\x16\x37\xc6\x42\x07\x9a\x35\xf3\x88\x71\xaa\xbd\x23\xc9\xe0\x84\x27\xb6\x13\xb0\xe5\x66\xec\x66\xa8\x05\xc5\xf1\x6c\xa7\xb8\x6d\x1b\x1a\x74\x1e\x27\x65\xb8\x25\x4c\x21\x53\x06\x6a\x36\x1e\x74\x38\xce\x2e\x16\x75\xa9\xc9\x42\x7e\x8d\x3f\x22\x7a\x33\x17\x0c\x89\xd3\xd6\xec\x97\x64\x31\xde\x27\xc7\x60\xc3\x8c\xa0\x5b\x8d\x51\x45\x0c\x9b\x0f\xb4\x23\xac\xb5\x14\x99\x67\x10\x67\x17\x33\x1f\x2c\xf3\x89\xab\x9c\xd2\x93\xb8\x02\x19\x9a\x51\x75\x33\xe2\x9e\xa6\x6c\x53\x35\x6b\x78\x85\xe6\xd3\x86\xde\x94\x41\x78\x0f\xd7\x1b\xca\xcd\xf7\x44\xe7\x90\x14\xdd\xcb\x9b\x82\xd2\xc3\xce\x00\x8e\x02\x7a\xed\xfa\x1c\x3e\xe5\xb5\x54\x14\xa7\x07\x3a\x71\xa1\xca\x29\x59\x44\x9b\xd8\x7c\xbd\xe3\xc5\x40\xf9\xa5\x84\xbd\x81\x07\xf6\x62\x15\xb2\x95\x53\x70\xbe\x5c\x77\xb5\x55\xd4\xa2\xcf\x7a\x27\xcd\x9a\xa2\x57\x00\x7c\xd1\x2b\x2c\x1c\x2a\x67\x7e\xbb\xb4\x29\x15\x19\x89\x09\x56\x25\x4b\x6f\x73\xf4\xfa\xd7\x34\xfd\x0d\x31\xce\x6d\x03\xa0\x54\x35\x9c\x22\xaf\xab\xb9\x88\x4c\x23\x18\x16\xec\xa6\xda\x42\xb2\x4e\xe3\x76\xe8\x6b\x42\x78\x31\xdf\x25\x03\xb1\x8e\xc1\x34\x22\xca\x11\xeb\x9c\x9f\x66\x43\x23\x06\xcd\x88\x3e\x5c\x76\x1e\xd7\x12\x43\x0e\x88\xd2\xb5\x20\xc6\x33\xb3\x2c\xbd\x14\xe9\xb3\x62\xc6\xbc\xc3\x45\x59\x21\x30\xca\x52\x70\x45\x3e\x37\x53\x8c\x58\x3f\x64\x19\xa4\x04\x5e\x1f\x94\xba\x7a\x0f\x3a\x24\xf4\x44\xe8\x5d\xcc\x8f\x3b\xc8\x91\x82\xbb\xe1\x24\xa4\x9f\x36\x27\x42\x40\xd1\xa1\x3a\x7a\xaa\x3b\xb9\x10\x9f\x3d\x40\xad\xd0\xfb\x99\x3c\xde\x82\xc9\x63\xa4\xdc\x84\x81\x8a\xec\x38\xf3\x74\xd2\x76\x71\x96\xbf\xd6\x6e\x55\xca\x26\x91\xfe\xc7\x57\x4a\xb2\x10\x02\x2f\xad\x40\x6a\xe7\xc8\xa0\x69\x9b\x4c\xb5\xc0\x34\x3c\x9d\x82\x83\x3c\x0c\xc2\xb4\x8a\xe6\x77\x62\x5f\x76\x14\x6f\xc8\x3e\x0c\x9d\x1a\x3e\xd5\xbe\x1d\x50\xfc\x35\xed\xaa\x19\xd4\xec\x86\x21\xa2\x5f\xc8\x46\x57\xba\x72\x79\x35\xc3\x18\x4c\x96\x15\xf3\x38\x16\x22\x3b\x25\xff\x6c\x44\x5f\xff\x5d\x79\xf4\xd0\xfe\xfd\x63\x80\xff\x89\xe8\xb6\x6f\x90\xaf\x97\xae\xd3\xe7\xd3\xbc\x99\x4d\x11\x73\x88\xb5\xd7\x71\x5d\xf3\x03\x98\x47\xa4\x3f\xed\xb8\xc0\xf6\xaa\x41\x66\xe8\x00\x51\xe8\x88\xe5\xc2\x94\x23\x92\x6d\xa9\xbb\x3b\x36\xd0\x96\x60\xdb\xfc\x40\x55\xa6\xc9\x45\x0d\xd2\xf8\xd0\x03\x1a\xcc\x0a\x9e\x30\x5d\xb9\x0b\x80\xc0\x71\x1a\xff\xc6\x67\xec\x05\xf5\x2b\x5d\xfc\xac\xf1\x59\x9f\xf6\x2b\x7d\x88\xc6\xbb\x8e\x92\x8e\xe8\xbc\x6f\x45\xb2\x6f\xf0\x52\xa6\x67\xb7\x00\xef\x8d\x4a\xe2\xcc\xf7\xd4\xf5\xc8\xa1\x67\x18\x1f\x52\x49\x17\x2d\x10\x3e\xf8\x53\x11\x3e\x08\x08\x1a\x44\xc9\x4b\x4c\x7e\xfc\x53\x35\x2a\x1d\x40\x23\x07\x30\x8b\xa2\x84\x52\x43\x73\x3a\x70\x29\x56\x6e\x63\x94\xc6\x3b\x33\xf9\x40\x7b\xd4\x85\xb3\xfa\x9b\x05\xbe\x21\x35\x69\x00\x3a\x90\x29\xb0\x2e\x30\x40\x97\x64\xf7\xe9\xe7\x79\xcf\x11\x1b\x75\x86\xc6\x64\x35\x52\x80\xd6\xd7\xa8\x56\x07\x2a\xd0\xb9\xaa\x73\x63\x37\xe4\x17\x14\xeb\xbe\x91\xe4\x32\x69\x82\xfe\x58\x17\x0c\x47\x0e\x88\x05\x1e\xc9\x5e\xbe\x4d\xdf\x78\x84\x50\xa0\x35\x19\xd4\x7f\x4c\x67\x6f\x47\x49\x67\x66\x01\xc3\x3e\x4e\xd1\xe1\x66\x89\xd3\xbb\x33\xcc\x8b\x85\x3b\xe2\xcb\x39\x48\x3b\x99\xfd\x31\x15\x3f\xba\x1b\xd3\x48\xec\x4a\x0f\xd5\x4e\x14\x2c\x9a\xf9\xf5\x32\xd3\x5d\x3f\xa6\x37\x3f\xf6\x87\xd5\xd8\x75\x2b\x4d\x29\xf1\x58\x12\x30\xdc\x9e\x72\x02\xc5\x1c\x89\x14\xf9\x78\xcf\xed\x92\x73\xe3\xb7\x90\xa8\x9f\x0d\xae\x3d\xee\xde\x89\xcf\xc0\x39\x44\x56\xce\x54\xa7\x94\x0d\xed\x4d\x99\x19\x88\x38\x26\x77\x34\x18\x8d\xb1\x8e\x84\xe9\x30\x16\x8a\x4a\x9a\x01\xdd\xbb\x13\xd5\xe3\xd0\xc2\xe7\x26\x85\x53\x18\xe5\xe3\xde\xf1\x83\xf3\x6e\xcf\x5d\x67\x0d\x8a\x7b\x5b\x31\x1c\x99\x10\xf9\x81\x2f\x27\xe6\x83\x75\x52\x00\x72\x08\x0d\xb0\x57\x8c\xe9\xeb\x09\x72\xe4\x97\x34\x62\x5f\x35\x5e\x42\xa0\xd1\xeb\xed\xf2\x1b\xdf\x6b\x22\x07\x10\xd4\x55\x27\x94\x33\xd6\xa9\xe6\xac\xcf\xfc\xd8\xa1\x8b\xb5\x2e\x63\x26\xff\x2b\x2e\x57\x0d\x42\x5a\xa0\x7e\x56\xb3\xb1\xf7\x36\x26\x14\xe3\xed\x20\x93\x95\xb9\xab\xe7\x14\xf7\x55\x7e\x1f\x72\xe3\x56\x1f\x84\x58\xb2\x30\x79\xe8\xe4\x5b\x71\xb9\xe8\xb2\xc9\xa2\xff\x88\xcb\x05\xed\xce\x13\x46\x9c\x4d\xd5\x8c\xe5\x21\xd0\x45\xe6\xc1\x4a\xb7\xda\x41\xea\x5d\x3b\x00\xc8\x13\x1c\x40\xd2\x3d\x45\x08\x2e\x75\x02\x88\x3e\xcf\x5a\x04\x58\x3d\x24\x5b\x66\x00\x6b\xc0\xac\x2e\x31\x2f\x51\xc3\x93\x21\xaf\x2b\x2e\x39\x50\x91\x9d\xc3\x5b\xfc\x59\x03\xde\x9a\x61\x14\x21\x53\x4a\x78\x02\xae\xb3\xfc\x27\xdf\xbd\xae\x7b\xf9\xaf\x32\xf9\xed\xef\x02\x48\xd8\x10\x20\x21\xa9\xf3\xa3\xd4\xb4\x48\x3a\x16\xe5\x70\xa3\x46\x95\x99\x95\x63\x05\x44\x81\x92\x73\xe9\xbc\x2c\xab\x78\xb5\xb2\xd4\x16\x83\x13\x13\xf5\x6b\xbf\x7b\x0a\xf7\x36\x6a\x61\xa0\x2a\x5e\x95\x18\x40\x68\xa0\xc4\xf7\x5d\xd7\x68\x20\x44\xd3\xc4\x65\xe1\xd8\xdc\x1f\x07\x55\xf7\xc8\x9a\xb4\x81\x13\xd5\xe8\x78\xa1\xba\xc8\x47\xd3\x19\xc7\x77\x98\x44\xc1\x53\x32\x20\xc8\x0f\xc7\x3b\xad\x3f\xf5\x3b\x78\x1a\xe9\x34\x0b\x5f\xce\xcb\x91\x1c\x5b\x2e\x1c\xde\x44\x29\xe8\x1a\x79\xfb\x47\xe0\x75\xa9\xf7\x98\x95\x61\x70\x47\xef\xe2\x01\xbc\x47\x63\x92\x0b\x79\x2f\x92\xf5\xdb\x9a\xeb\x5a\x75\x36\x13\xa9\x2b\xea\x61\x33\x60\x6e\xc9\x0f\x4d\xd7\x40\xa7\x1a\xbf\x02\xf0\xcb\x02\x20\x7e\x3d\xe7\xf4\x37\x45\x8c\x3f\xba\x7d\x26\x49\x1f\x16\x8f\xfc\x01\xc9\x73\x85\xf3\xef\x93\xbe\xb1\x89\x6d\xde\xfa\x82\xd4\xf6\xb1\x09\xe5\x0f\x50\x1b\x95\x53\xa6\x97\xa0\x8f\x13\x41\x4e\x53\xf0\xb6\x1a\xc9\x49\x3b\xcc\x4f\x0b\x49\xc1\x5b\x3d\x07\x44\x0b\x00\x7c\xcf\xf2\xb4\x42\x3f\x0a\x83\x81\x4a\x05\x12\xec\xdf\x8a\x01\xf2\x31\xd7\x12\xbe\x0f\x5d\x50\x15\xbc\x74\x3b\x02\x62\xf4\xcc\xdd\x49\xd1\x28\x86\x26\xff\x01\x87\xf2\x72\xcb\xa0\xb6\xb6\x96\x78\x31\x29\x95\x1f\xa2\x40\x70\x6b\xa9\xe5\x9c\xd0\x3f\x15\x24\x83\xdb\x96\x7c\xa1\xdb\xfa\x23\x9f\xd4\xe3\xc6\x8c\xe4\x21\x29\x0f\xc4\xa2\x0c\x6d\xf1\x60\xb1\x92\xdb\x2e\x15\x6b\x45\xe2\x0e\x3c\x60\xea\x37\x8a\x4d\xc1\xdf\xc4\x02\xbc\x65\x17\x85\xee\x6d\xb1\x33\xb7\xea\xd0\x62\x31\xc6\x64\x0a\xad\x9e\x2a\x8d\x57\x2d\xcf\x2d\x79\x51\x21\xb8\xcb\x0c\x1a\x34\xbf\xb0\xc3\xec\x2b\xa5\xe9\x98\x8c\x31\x5b\x98\xad\x84\xd2\xaa\x88\x71\x71\xcf\xe5\xc8\x20\xd6\x21\x15\x98\xc1\x3c\xd3\x88\x90\x2b\xc6\x28\xe7\x18\x79\x4a\x46\x3b\x61\x56\x76\x89\xb7\xa8\x4f\xbb\xb1\x6a\x77\x69\x4d\x8b\x67\x25\x3a\xd0\x4d\x76\x13\x6a\x39\xf2\xd9\xb6\x91\x1b\x7e\x2b\x66\x82\x89\x08\x22\x67\xba\xec\xf1\xa9\x33\xb0\x11\x89\x58\x74\xc1\x26\xa2\x70\x75\xac\x12\xb8\x8e\x4c\x66\xa4\x61\x42\x27\xdf\xed\x41\x04\x23\x69\x5a\x64\xd2\x38\x95\x1b\xc6\xdf\xdc\x56\xf9\x0b\xfc\x99\x47\x7a\x46\x64\x1b\x6c\x92\x72\x93\x86\xb9\x79\x81\x87\x28\x93\xb9\x6b\xc2\xea\x95\xc2\x7d\xe0\xa3\xd4\xd6\x4e\xc9\x0c\x0e\x2b\x2c\x67\x8e\x9a\xe6\x8f\x57\x6b\x46\xa9\xd8\xd3\xfd\x15\xbf\x04\x7f\x24\x07\x71\x45\x95\xe9\x47\x08\x52\x28\x9b\x2b\x06\x35\xe0\x58\x7a\x83\x03\x97\x9d\x07\x94\x8a\x05\x55\x38\x07\x0c\x3e\x26\xe9\x4e\x99\x9a\x20\x76\x38\xb4\x5a\x64\xa8\xb6\x7b\x09\xe6\x64\x15\x1f\x59\xc6\x3a\x4d\xe9\x9e\xc1\x44\xe5\x2f\x74\x34\x1b\xed\x1c\x17\xc4\x25\x5e\x33\xce\x64\x12\xd0\x16\xa8\x1f\xd4\x90\xb7\x16\xde\x8d\xac\xfe\x0e\x59\x3f\x3b\xae\x81\x44\x66\x80\x4e\xb1\xd4\xb7\x62\x95\x12\xdc\x11\xe2\xdc\xe7\xc0\x9e\x9c\x94\x2c\xec\x0b\x98\xe2\x9f\xb3\x0e\x0e\x56\x05\xaf\xa2\x69\x76\x00\xed\xfa\xf0\x03\x21\x2f\x61\xd8\x5d\x95\xed\xe0\x38\x41\x2b\xb9\xff\xe1\x84\xe4\x5f\xf6\xe5\xe1\xf0\x2f\xcf\x33\x1c\x97\x30\xfd\x41\x36\xec\xcf\x0f\xc4\xa9\x51\x35\x24\xd8\x62\x47\x94\xd0\x95\x21\x2c\x56\xff\x39\x4f\x36\xa9\x45\x96\xdc\xe7\x89\xf2\x2b\x34\xd2\x5d\xac\x5f\xe1\xe1\x9e\xfc\xda\x1c\xa8\xaa\x24\x99\x1f\x7a\xd9\x73\xb8\xf2\xae\x6e\xc8\x23\xa8\xac\xdc\xc4\x53\x57\x57\xb9\xd1\x0a\x5c\xfc\x69\xe9\x54\x01\x55\xf5\x07\xe1\x80\x89\x16\x01\x10\x6e\x46\x8a\x1c\x09\xef\x57\x1e\x61\x04\x04\x2f\x1b\x01\x3f\xcb\xc9\x44\xec\xe4\x49\x29\x32\x09\xba\x02\xf5\xa5\xa9\xcd\x89\x1c\x82\xdd\x66\xc5\x2c\x4e\x6e\xd9\xa8\x34\xc8\x1a\x57\x47\x50\x99\x55\x56\xfd\xf3\x1d\x3e\x8d\xa6\x4a\x81\xa6\x2c\x28\xd7\x0d\x30\x30\x9b\x1f\x76\xa1\x08\xdf\xc3\xf5\xed\x39\xee\x41\x97\xde\x5e\x4f\x69\x61\x64\xd0\x4f\xb9\x68\x8b\xcf\xb6\xe4\x67\x87\xcf\x69\xcf\x3a\xcc\x9d\x70\x26\xe4\xea\x49\xd6\x97\x92\x06\xca\x82\xe5\x5b\x15\x26\xee\x57\xbc\x17\x48\x15\xa8\x67\x27\xeb\x2d\x70\x07\x58\x4e\x27\x66\x99\xa8\x50\x62\xfe\x3b\x29\x40\xeb\x14\x70\xba\x2d\x02\x20\x02\xa7\xa3\xf3\xfb\x2c\x8f\xf7\xa0\x19\x7b\xa1\xfa\xcd\x88\x55\xaa\xd5\xd1\xf5\x93\xea\x95\x6d\xb6\xd2\x43\xa4\x8e\xeb\x8a\x9b\x8c\x85\x7d\x9a\x49\xde\x05\x25\x44\xe1\x14\xaa\xbe\xfe\x32\x28\x6d\x4e\x25\xaa\x9a\x8d\xef\x6e\x72\x4c\x58\x36\x0d\x89\xa7\x93\x06\x9a\x77\x78\xfd\xd3\xf0\x5c\x78\x45\x4c\xee\xe8\x50\x37\xf6\x25\x51\x48\x95\x10\x76\xdc\xee\x2b\xb9\x9f\xad\x11\x3f\xf3\x4d\xce\x32\x55\x62\x85\xe1\xcb\x9f\x75\x74\x18\x4d\x69\xf8\x89\x95\xab\x81\xf7\x1b\x05\xd8\x34\x6d\xd3\xf4\xcb\x64\xd6\x66\x12\x9a\x77\x3b\xf5\x1d\xe6\x16\x71\x46\x12\xac\x50\x2a\x5d\x5d\x87\x7e\xe1\xf4\x21\x9a\x03\x4f\x11\x51\xf5\x51\x3c\x25\xd8\xb9\x9e\x59\x9e\x36\x32\x55\x9d\x55\xd4\x1d\x4d\xaa\xb8\x07\x21\x6a\x49\xd2\xc1\xd2\x12\x02\x97\xc7\x51\x00\xf3\xc1\x98\x12\x1c\xc2\x92\xa0\xc4\x20\x39\xd8\x10\xd5\xf3\xde\x88\xe8\x42\x7b\xd2\xbb\x58\x00\x53\x23\x71\xb8\x00\x68\x63\x0d\x6d\xe1\x63\xd9\x4a\xd3\x84\x76\xc1\xca\x5f\xed\xd8\x0e\xde\x21\x86\x98\xbf\x8b\xac\xe4\x3d\xc4\x67\x7f\xef\x8a\xcd\x31\x22\x3f\x71\xbf\xab\x1a\x91\xf3\x73\xaa\x30\x69\x35\x11\xfe\x8a\x27\x86\x31\x75\xc5\x8c\x5b\x1c\x36\x7e\x87\x19\x1d\x17\x4b\x17\x0d\xd0\x3a\x0c\x7b\x44\xbd\xa6\x23\xbd\x0c\xfa\xa8\xd4\xb0\x45\xc2\xc7\x82\x40\x4c\x05\x6f\x10\xde\x98\xa9\x8c\x64\x44\x43\x77\xe9\x2c\x87\x63\x69\x33\x77\x69\xc6\xcb\x9e\x82\xfd\x4c\x6f\x9b\x49\xf0\x80\xaf\x66\x90\x54\xfb\x4e\xe3\xba\xf6\x2a\xae\x1f\x90\x2e\x88\x3e\x1a\x98\x3d\xdf\x31\xa9\x8a\xa8\x6a\x4a\x90\x18\x6e\x0c\x3a\x70\x5b\x3a\xab\x40\xff\x61\x2f\xb0\xfd\xbb\x52\x8e\xf9\x6f\x5e\x80\x3a\x4e\x08\x62\x02\x3b\xc0\xf7\x15\x83\xcd\xe1\x73\x9f\xb5\xf6\xd2\xad\x83\x42\x45\x71\x36\x41\x50\x83\x34\x89\x05\xee\xca\x6f\x2e\x7a\x92\xfd\x64\x79\x80\x61\x03\xf1\xc7\xff\xb8\x39\x62\x1d\x41\x2d\x95\xa8\x6b\x58\xef\x47\xac\x9b\xab\xc2\x55\xde\x3e\x3f\x81\x36\xc8\x2c\x9d\xbc\x9f\x83\x2d\x38\x84\xd7\xb2\x31\xc7\xb6\x6d\x47\xa5\xd4\x65\x8a\x92\xfc\x1e\x8a\x96\xb4\xd5\xe4\xcb\x67\x8a\x87\x00\xcd\x84\x85\xdb\x7d\xe0\xa3\x22\xd8\x9b\x10\x18\xe8\xb9\x55\x2d\x0e\xc7\xbf\xb2\xea\xd7\x03\x7e\x4c\x46\xf9\xac\x02\x50\xb1\xd6\x67\x4c\x4d\xce\x31\x53\x52\xa3\x62\x4c\x7a\x28\x62\x82\xc8\x1f\x5a\x2f\x7c\xe8\x16\xcd\x7b\x00\x85\x2b\x17\x1e\xa4\x30\x6e\x0b\xf0\x20\x25\x41\xf6\x3a\x85\x1d\xb9\x4f\x25\x54\xea\x3b\xc0\x28\xfd\xed\x87\x42\xc7\x98\x42\x92\x38\x37\x27\x8f\x42\xfa\xaa\x8d\xe2\x68\xf5\x12\x53\x58\x43\x9f\x76\x0a\x15\x72\x8a\x25\xd1\x24\xd0\xf3\x79\xd6\x01\x74\x33\x2c\xe7\x79\xca\x64\xec\x91\xd0\x6c\xde\xb9\x6c\x0c\x88\xd2\xe0\x7e\xa7\xa2\x1f\xe9\x2f\x79\x39\x0b\x59\xf2\x73\x6d\x5f\x51\xe4\x64\x94\x74\x5a\x21\xaa\x24\xba\x1a\x4f\xef\xc7\x7f\x12\x02\x72\x6d\x8a\xae\x77\x2e\x97\x0e\x42\x90\xac\xa6\x2e\xc9\xd9\x93\x9e\x88\x18\x4e\xdb\x89\x94\x7e\xf2\x1a\x28\xd5\x10\xaf\xf9\xac\xa6\x98\x1f\xac\xe4\x7e\x2e\x18\x5f\x00\x33\x26\x1f\x91\x3a\x53\x0b\x8a\xa3\x29\x0d\xbb\xb3\xe2\xc8\x3c\x84\x9e\x58\x1f\x61\x30\xc5\xb5\xf0\xdc\xc1\x84\x92\x64\x6b\x23\xd3\x29\x27\x28\xe2\xb8\x88\xa2\x22\xcf\x10\x11\x8d\x0a\x16\x63\x19\x99\x61\x8d\x64\xde\x69\xf6\xed\x1e\x3c\x25\x2e\xd5\xd1\xe3\x7b\x62\xd7\x3e\x7f\x3c\xfd\x08\xd7\x68\x90\x2f\x78\x3f\x38\x5d\xe5\x60\x0c\xe7\x05\x3c\xd2\x09\x58\xcc\xaf\x4c\x99\x07\x5d\x44\xf3\x64\xb0\x77\x26\x1d\x99\x43\xda\x3c\x59\x7f\xe7\x25\xa4\x4b\xdf\x81\x0e\x15\xa3\xda\x41\x01\x9b\xb8\x17\x56\x82\xe9\x43\xcc\x82\xb0\x5a\x48\x38\xdf\x3d\xa6\x95\xcb\x7a\x1a\x93\xb4\x15\x9a\x25\x72\x91\x46\x33\x39\xc2\x42\xdd\xbf\xf6\xbb\x16\x1a\xad\x3b\x52\x46\x6d\xdc\x15\xd1\x3d\x0d\x18\x57\x96\xed\x8e\x25\x67\x6e\x2b\x45\x65\xbb\x9b\xba\x4b\xb5\xf7\x52\x26\x51\x4d\xb0\xd8\x91\xf4\x7c\xef\x59\xcb\xe5\x6e\x1b\x8a\xfc\xbc\x64\x03\xc7\xf7\xb8\x31\x86\x24\x17\x38\x44\x04\xb7\x63\x8e\x2f\xc1\x87\x21\xf8\xfd\x76\x19\x40\x1d\x11\xd1\x12\x8a\x64\x7e\xfe\xe1\x9c\x0e\x31\x33\x35\xf6\x10\x22\x17\xc2\x3c\x04\xc1\xc0\x95\x54\xbf\x9d\x35\x90\x8b\xc1\x5e\xd8\x9d\x10\x9e\x04\xdd\xac\x00\xfd\x54\xb9\xb1\x12\x24\x8c\x5f\x21\x31\x76\x4d\xb7\x87\x09\x4d\x9d\xda\x92\xfa\x7b\x2e\xef\xf5\xa3\x7e\x4e\x65\xd3\x5d\xa8\x16\x3f\x4f\x6b\x54\xc0\xff\x89\xc5\x9b\x54\x79\xec\xdb\xa0\x2b\x36\x8c\xe8\x2c\xf9\xa4\x58\xec\x93\xef\xff\x64\xba\xf2\xcb\x7e\xff\x2e\x77\xb1\xfe\x9d\x34\xfc\x57\xbf\x16\x41\x59\xcd\x3b\xa6\x71\x07\xb5\x29\xc3\x39\x01\xac\x0b\x9a\xc6\x19\x45\x76\x90\xbd\xef\xce\xce\x1e\x3f\xbb\x73\x5c\x98\x00\x62\x06\x89\xd9\x70\xf7\xeb\x82\xcc\xe4\x6e\x58\x6c\x9e\xb5\xe7\x54\x47\xd3\x98\x80\x80\x80\x89\x9a\xd4\xf9\x37\x79\xe3\x88\xc5\x9c\x5f\x50\x00\x8d\xd3\xdf\x87\x56\x14\x25\x59\x45\x41\x65\x1b\x5d\x5d\x5c\x6b\xc9\x23\x38\x5e\xc6\x72\xe6\x57\x14\x83\x1f\x06\xb0\xb7\x3f\xe6\xd7\x4d\xe6\x71\xd9\x50\x39\xd9\x12\xba\x00\x37\x52\x04\x58\x14\xc5\xb9\xc6\x81\xc5\xfe\xe8\x12\xe0\x2f\x79\x8a\x0a\x8f\x2f\xb4\x1f\x65\x19\xa6\x6b\x7b\x60\x4f\xa0\x89\x5e\x7c\x1a\x0b\x31\x47\xa3\x19\x3c\xa7\x4a\xb3\x04\x43\x15\x71\x8e\x7c\x38\x31\x3f\x18\xba\x74\xe3\x5e\x5c\x12\x4d\xea\x7c\x97\x19\x6d\x29\x08\xe1\x4c\x0b\x68\x0b\x0d\x6f\xd3\x21\x31\x86\xe2\x1d\x46\x49\x9f\x8d\x39\x99\x96\xb5\x15\x43\x4c\x56\x27\x64\x42\x16\xe3\x6c\x2f\xed\x85\xef\x82\xef\x4a\xc6\x8f\x9c\x77\x4c\x40\x75\x10\x26\x3f\x31\x8a\x9a\xe6\x4f\xc9\x19\x86\x41\x17\x30\xd4\x10\xfb\xe6\xd5\x85\xfc\xe1\xe2\x4b\xa6\xee\x79\x75\x98\x2d\x7a\x04\xb0\x29\x71\x19\x26\x3c\xa5\x36\x04\x1b\x14\xa7\xc5\x53\xec\xf2\x79\xfa\xe8\x46\x6f\x57\x34\xa1\x36\xf8\x86\x13\xdd\xc1\x28\x8a\x90\xb5\x54\xb8\xa8\xd8\x03\x4e\xb2\x3c\x29\x41\x5e\xf7\xde\x6f\xcf\x53\x39\xc7\xbf\xf2\x6e\x0d\x55\x55\xb9\xa8\x17\x3c\xc2\xe0\x5a\x53\x40\xb0\xb5\x93\x88\xaa\x21\xd7\x6d\x14\x87\x54\x55\x0f\xc1\x2f\x87\xd1\xd0\x36\xfc\xfd\x57\xf8\x8e\xf7\x3d\x29\x08\xcc\x90\x14\x32\x84\x20\xe5\x9e\x54\x36\x12\x7d\x2d\x30\x5e\x37\xc8\x2c\x36\xb9\x45\x0d\x24\xe4\xb9\x65\x09\x4c\x59\xcb\xfb\x14\x7c\x05\x8f\x9f\xba\xa3\xca\xba\xc6\xde\x6f\x14\xcd\x41\x42\xcc\x5d\x5e\x4d\xfa\x0a\x9b\xc2\x28\x91\xa4\x81\x2a\x74\x02\xa9\x37\x2a\x52\x9a\x10\xcc\xa6\xa7\x00\x95\x83\xd2\x3e\x02\xa9\x15\x8e\xaf\xc1\x4e\xd0\x03\xc5\xcd\x08\xef\xcf\x4e\x01\xe5\x2d\x3f\x77\x79\xb3\x16\x98\xf4\x17\xe9\xf6\x3c\x62\xef\x4a\xf0\x54\x61\x66\xe9\x0d\x80\x5d\x83\x0e\x72\x5a\x72\xac\x68\x60\xd8\x86\x92\x7b\xf7\x87\x94\x74\xd2\x42\xad\x3f\xb2\xa3\xbb\xd7\x33\xc0\x63\x57\x03\xb1\x57\xc0\xd1\xbf\x74\x13\xb8\x40\x3d\x07\xd2\xff\x7e\xf0\x97\xb5\x5c\x32\xb2\x84\xac\x32\xae\x60\xdf\x75\x9e\x1b\xec\xa7\xb3\xdf\x9e\x07\x5a\xa8\x40\x1b\xdb\x38\x43\x01\x78\x4f\x13\x05\x49\xa6\x30\x9b\xb5\x6a\xb7\x16\xab\x44\xde\x48\x63\x96\xf1\x21\x98\x5c\x72\x26\x9a\xbf\x83\xdf\x35\xbf\x0e\xbd\x9f\x5a\x6d\x4a\x03\xe6\xae\x79\xf7\xc5\x28\x2a\x8c\x5e\xd9\xe8\x9e\xbd\x79\x7b\x52\x1e\x87\x85\xac\x7c\xcf\x2d\x1b\xc7\x8a\xb6\x14\x89\x1b\xf3\xb4\xf3\xb1\x1d\x16\x37\x45\x3b\x0d\x25\x0d\xe8\x00\xe7\x33\x8c\xb1\xdd\x2f\x90\x7e\xe3\xc9\x36\xff\x68\x61\xf3\x97\xff\xab\xbc\x46\xf7\xff\x2f\x72\x6c\xc2\x7f\x52\x8d\x51\x08\xc0\x29\x6b\xf0\x1a\x79\xd5\x36\xd6\xef\x47\x39\xa0\xa1\xdb\xf6\x50\x88\xcf\xde\x06\x18\x1a\xc1\x8b\x13\xb6\x8b\x0a\x8d\x8e\x38\x3c\x92\x53\xe5\x44\x52\x3b\xfc\x04\x32\x7f\xa1\xa3\xac\x6e\xa8\x55\xb1\x3f\x18\x85\x45\x8b\x14\x40\xa7\xe1\xb2\xa8\x2a\x3e\x14\x53\x3e\xd5\x56\x45\xa2\x68\x6d\xc1\x49\xce\x2b\x91\x47\x01\x60\x03\x97\x6f\x11\xc6\x64\x04\x3e\xaf\x85\x5e\xe5\x7e\x86\xda\x76\xcd\x02\x29\xa7\x08\x0a\x91\x14\xfa\x1b\xdf\x85\xcc\x43\xb6\x2b\x3c\xe9\xad\xfb\x3d\xbc\x97\x6f\x99\xc2\x5c\xb1\x2b\xb0\x00\xc4\x69\xb7\xe5\x7a\x71\x35\xb5\x84\x65\x9f\x6c\x63\x99\x4d\xfb\x30\x67\xb0\x8c\x81\x31\x73\xe6\xe9\x9c\x43\x42\x97\x6a\xee\xf3\xb1\x3b\xdc\x7b\x50\x9a\x5b\x01\x03\x8a\x03\x1b\xca\xda\xd6\x86\x7b\xbd\x8d\x48\x59\xe4\xb1\xef\xab\xd0\x9c\x46\x15\xfd\x88\x93\xf7\x0d\xb5\xd1\xa5\x40\xbc\x15\xf3\xf9\xb2\xe8\xe6\x18\x7f\x92\xd7\x5b\x22\x60\xad\xf1\x90\x5c\x5d\xf4\x2e\xd4\xc4\x79\x98\x4b\xe4\x9b\x85\xad\x14\x71\x4d\xe8\x85\xd5\x1c\xc6\xff\xec\xfa\xc6\xce\xb9\x87\x63\x93\x50\x2f\x36\x73\x8e\x9e\x6b\xbf\x20\xd6\x30\x74\x0f\x03\xec\x36\x45\x95\xc1\x50\xff\x02\x59\x12\xad\x4a\xe7\xf6\xa7\x5a\x69\x99\x9e\x0b\x75\x22\x28\x6d\xa6\x87\x95\x50\xf4\xb4\x96\x2b\x99\x82\x51\xe8\xdf\xdc\xb3\x1d\xd3\x1f\x6c\x22\x9c\xa8\x24\x54\x2d\xbc\x6b\x2a\x94\xc4\x2e\x41\xed\xa1\x72\xf6\x9f\xd2\x7e\x77\x42\xf1\x02\x2b\xa7\x5b\xa7\xbb\xda\xd0\x15\x0e\x5f\x5f\x0c\xfb\x64\x9d\xe3\x17\x58\x02\x72\x04\xbe\x72\x56\x7c\x17\x7d\x31\x8d\x97\xda\xc8\xc7\x78\x77\x58\xb5\x26\x5d\xdd\x39\x51\x33\x2d\x7a\x7a\xdb\x11\x21\x3b\x12\x44\xea\x4d\x61\x35\x9a\x05\x05\xcd\xc8\x68\x96\x7f\x80\x02\x00\xd1\xf5\xcd\x74\x41\x14\x90\x0e\x23\xd0\x4f\xa0\xa1\x7d\x7e\x2d\xd3\xde\xed\x6b\x1a\xca\x46\x28\xf0\x5e\x5a\xca\x0b\xfd\xe3\x52\x10\x0b\x15\x43\x63\x4e\x28\x96\xfa\x35\x20\x4b\xc4\xa3\xda\x01\x5a\x39\x41\x97\x85\xef\xd7\x6b\x33\xe7\x58\x89\xba\xf0\x00\xff\x9c\xb0\xfb\x76\x77\x30\xe1\x7a\x66\xf0\x0b\x6d\x8a\x07\x52\x6c\xbc\x7e\x25\xd8\xe2\x88\x2b\xe8\xac\xb5\x0f\x1a\xbf\x49\xc1\xc5\x21\xaa\xf2\x03\x30\xd7\xe8\x58\xa0\x1e\x71\x26\x67\xb0\xfa\x94\x6e\xd7\xbb\xdd\xfa\x38\xfd\x0c\x10\x20\xf5\x00\x28\x0a\x72\x74\x7f\x7d\xdc\x52\xe0\x18\xea\xae\x86\x2f\x97\x1e\xc5\xcd\x68\xed\x9d\xf5\x94\x07\x05\x32\x4e\xc2\x7c\x17\xb5\xe5\xd3\x49\x5c\x8d\xf0\xcf\x5a\xf3\xf1\xef\xd2\x25\x55\xf8\x5f\xe6\x0c\xc1\xf6\x7f\x6a\x96\x73\x3a\x95\xb8\xe8\x5d\x8d\x9e\x88\xe7\x1d\x1d\xb4\xd0\xc8\xaf\x90\x2d\x0f\x41\x55\xbc\x5a\x5d\xf2\x75\xab\x60\xeb\xdb\xf2\x05\x9b\xa0\xd3\xa4\x88\xc9\x61\x0d\x3a\x04\x8c\xa3\x89\x9a\xd4\xf6\xa1\xb6\xb9\xbf\x2b\x9f\xdd\x71\x6e\x0f\x84\x40\x44\xb9\x7e\x81\x97\xa2\x48\xd2\xb6\x0d\xea\x23\xe1\x95\xe3\xb4\x16\x03\xff\x58\xac\x9f\x5a\xc7\xc2\x87\x10\x61\x5f\x23\xd3\xbc\x9b\xf8\xcf\xd6\xb4\x28\x0f\xd7\x87\x04\x2a\x0d\x8f\x4f\x64\x78\x8d\xc3\xf4\x4b\xbc\xa4\x8c\xb2\xed\x54\x9a\xb5\x2c\x32\x3b\x44\x85\xce\xfa\x17\x0e\x5e\x66\xf3\x6c\xc5\x35\x5c\x22\x9d\x16\xb3\x6a\x4d\xd9\x30\x58\xb2\x8e\xc1\x20\xba\x04\x4d\x34\xf2\x44\x13\x28\xbe\x76\x66\xa6\xbd\xdd\x69\x52\x87\xfc\x21\x0c\xc2\xc3\x81\x68\xd2\x10\xe1\x3a\x57\xa4\xa0\xdf\x60\x40\xe6\x59\x63\xa0\x38\x2c\xbc\x4e\x8a\x99\x0a\x1e\xf0\xbc\xb2\xe1\x0e\xc0\x5c\x91\x8b\xb7\xd9\x7e\x6f\x16\x64\xb4\xf0\xd3\x50\xcc\xed\x65\x33\x19\x9b\x50\xe3\x64\x1c\xba\x49\x81\x65\x97\x26\xf7\x33\x90\x09\x0d\xdc\x6b\xd8\x72\x86\x9a\x02\x61\x0c\xbe\xb7\xf7\x5c\xb4\x3f\xe4\x79\x2b\x3a\xdb\xef\xca\x23\x66\xc0\xf4\x73\x89\x62\x39\xae\x0e\x0e\xbd\xaf\x6b\x24\x5a\xc2\x39\x5c\x19\x99\xf8\x88\xd6\x08\x0e\x55\x40\x85\x77\x48\xea\x55\xc4\xae\xa0\xd3\x51\xc7\xf4\x48\xd1\xa8\x3c\xc6\x71\x59\x39\x42\x7f\xb0\xbc\xd1\x30\x0b\x84\x0b\xeb\xb8\x7d\x87\x01\xc2\x23\xee\xd7\x47\xc8\x1f\xd9\x4f\x64\x72\xe3\x96\x4c\x23\x4c\xa1\x6a\x11\x2d\x61\xde\x22\xb7\x5f\xfb\x82\x63\x9c\xb3\x34\xe5\x4c\x13\xb2\x70\xb1\x89\x47\xd9\xbd\x87\x88\xcf\x70\xc2\xa2\xc6\xdb\xed\x6b\xd6\x9e\xa3\xec\xe1\x22\x67\x31\xa5\x0f\x63\xae\x36\x4b\xa9\x41\xfb\xda\xb3\x1c\xf1\x19\xbf\xd6\x2a\x5c\xa5\x22\xa3\x7f\xaa\x8a\x19\x9a\x85\x1b\xc2\x71\x61\xbe\x17\xb3\x64\x08\xe6\x3f\xaa\x73\x74\xe3\x03\xb2\x71\x72\xd3\x28\xbf\x96\x05\xdf\xe8\xcd\x1d\x9f\xbb\xba\xb9\xa6\x8a\xf3\x0a\xdd\x7e\xa1\x85\xa7\x43\xc0\x83\x74\xaf\x4a\xae\x6e\x67\xd6\x44\x70\x56\x47\x23\x7e\x00\xf3\xf9\x93\x54\xf4\x39\xb9\x3c\xc4\xff\x7e\x87\x6a\x01\xf1\xad\x18\x0c\x1b\xad\xf4\xec\x01\x62\x93\x2d\xff\x24\xff\xde\xb3\xfd\xdf\xa5\x78\x7f\xd5\x35\x14\x5b\x28\x12\x60\xc3\x9a\xcc\x2b\xf7\xf0\xf6\xcf\xfb\x71\x2c\x8f\xff\x54\x19\x33\xfc\x0d\x56\x32\xdb\x26\xc8\x31\x96\x1c\xdb\xa5\x51\xb9\xe6\x3d\xd4\x91\xe4\x09\x2a\x1d\xbb\xa6\x3c\xd4\x85\x5f\x68\x1a\x02\x7c\x3b\x48\xb8\x64\x41\x4b\x14\x53\xe8\x57\x03\x1e\x24\xe8\xfa\x4b\xbe\x71\x50\x7a\x0a\x50\xf8\x07\xb3\xe6\xf6\x28\x24\x78\x2c\x25\xa1\xa9\x24\x78\xcf\x67\x83\xa8\x78\xa8\x4b\x22\xf7\x4a\xa6\x80\xf8\xe3\xef\x3c\x0a\xa1\xc4\xa3\x3a\x45\x6e\x88\x4a\x82\xef\x52\xda\x69\x65\x10\x87\x1c\x51\x47\x45\x6c\xcd\x80\x63\xf9\x1c\x55\x47\x85\x0f\x4e\xe3\x85\x7b\x83\x17\x1e\x85\x4f\x10\xbd\x17\x20\xd3\x4f\x10\xc3\xbb\x1b\xa3\x67\x1e\xa3\xa3\xee\x3f\x2e\xb3\x83\x1e\x93\x5f\x60\xb3\x5f\x5e\xf3\x65\x1a\x85\xfb\xaf\xab\xc7\x1a\x5b\x56\x87\xb4\x5f\x3d\x57\x48\xfe\x7b\x3c\xc5\xe4\x4e\xb6\xa7\x2e\xa5\xec\xde\x56\x47\x5d\x25\x5a\xa2\xfa\x5c\x7c\xfa\x44\xbf\xe9\x4b\x3d\x96\x3f\xe0\xfa\xc7\xbc\xfa\xa7\xbc\x7a\xac\x0e\x69\x07\x7f\x55\x84\x43\x49\xdc\x1c\xf9\x6c\xf4\x7f\xc3\x15\xd2\xd8\xfc\x23\x8c\xdd\xa5\x34\x5e\x79\xc7\xbe\xa9\x94\x10\x49\xa4\x5e\x65\xec\xd0\x4a\xa7\xfc\x35\x07\x12\x7c\xff\xfd\x99\xf9\x6c\x9c\xff\x35\x27\x67\x82\xd0\x87\x8e\xb6\x6d\xc1\x51\x8f\xde\x33\x97\xd2\xb1\x58\x1e\x3d\x67\xf1\xad\x58\x1e\xb3\xa6\xef\x43\x5d\x26\xbb\x50\xc1\x2f\x97\x8e\xe0\x9f\x3e\xfd\x39\x57\xfa\x7f\xd6\x93\xc6\x92\x98\xb9\x0c\x0f\xbb\x75\x04\x3e\xf4\xf7\xaf\x67\x16\xa8\xeb\xa5\x51\x42\x2b\x53\x0b\x95\x32\x43\xe8\x2f\x7d\x16\xef\x7f\xaf\x7f\x9f\x23\xd0\x55\x49\xe2\xad\x7f\xc2\x69\x70\xf4\x17\xca\xe3\x9d\x7a\xb4\x97\xc6\xe6\x55\xc6\x6a\xff\xc7\x5e\x4a\x3b\xa3\x53\xe4\xf6\x28\xf8\x95\x2f\xa6\xb0\x2d\x25\xfa\x0d\x25\xfa\xca\x79\xa8\x73\xfe\x1c\x7f\x13\x48\xed\x55\x4a\xf4\x97\x49\xf4\xad\x08\xa6\x6f\x76\xcc\x12\x22\xe3\x99\x4a\x34\x5a\xbc\xc3\x9f\xbf\x17\x60\xd3\x1a\xc6\xb3\x40\xdd\x36\x9f\xcc\xd1\x0b\x1c\x5a\xf9\x63\xaf\x70\xf8\x9a\x45\x0e\x61\xf0\x26\x6f\xf8\x2c\x6b\x40\xaa\x64\xf8\x02\x6e\xf8\xa2\x68\xf8\x0d\x6a\x42\xa6\x68\xf9\xca\x6b\xf8\x0e\xe2\x7c\x2d\x6b\x0e\xce\xdf\xf0\xdc\x2b\x41\xc3\x23\x8d\x70\xe8\x6f\x78\xc3\xff\x8a\x67\xfe\x8f\x78\x76\xc7\x50\x7f\xac\x8f\x1f\x40\x84\x2b\x85\x6f\x16\xa7\x63\x2a\xa4\x6f\x8e\x40\xcd\x7f\xcd\x21\x91\x45\xf8\x57\x4a\xe2\x99\x20\xa1\xea\xf2\x50\xf7\xc7\xfd\xfa\x34\xae\x29\xbf\xdc\x06\x64\x3c\x86\x20\x7c\x56\x90\x3c\x86\x3f\x3c\x46\x10\x3c\x16\x5f\xa0\x0e\x14\xe0\x46\xaf\x3c\x26\x9f\xf2\x96\x20\x20\x2e\xa7\xfc\x37\x5e\x2a\xd1\x7d\x19\xc1\x63\x3e\xbb\x7f\xc3\x73\xff\x17\x3c\xe7\x7f\xc6\xbb\xfe\x18\xbb\x8e\xfe\x5f\xec\xc5\x3f\xf6\x28\x47\xff\x67\x3f\x06\x83\x2b\xfd\x79\xdf\x9f\xf6\xf6\x1f\xfb\xf3\xb1\xc6\xe6\x69\xac\x90\xc4\x3e\x43\x42\x48\x91\xc2\xf3\x0f\x3b\x2f\x3a\x05\xb4\x17\x12\x89\x83\x82\x61\x18\xb5\xf0\x02\x97\x0d\xe5\x3e\x6b\x45\xb5\xf4\x1f\x93\x15\x79\x38\x7f\x87\x02\x3c\x8e\xab\x3c\x8e\x23\x92\x1a\x05\xca\x93\x5f\xd0\xf0\xe9\x62\x26\x9b\xab\x42\x30\x36\x18\x6e\x2c\x5f\x37\x0b\xb6\x8e\x2f\x83\xb7\xd8\x1a\xae\xa0\xd6\x22\xeb\x3c\x6c\xdf\x1a\xae\x22\x0a\x8e\xc7\x31\xa3\xf3\x68\x89\xd4\x34\x5d\x80\x56\xa8\x9c\xcf\x75\x8c\xe4\xe2\x01\x0b\x01\x3d\xd0\x13\x3d\xe5\xe3\x87\xaf\xd8\x37\x7e\xa2\x29\x3c\xc9\xb4\x9e\x15\xd8\x4f\xbe\x97\xde\xb8\x9d\x32\x23\x6c\x30\x37\xef\x43\x05\x69\x91\xc8\x7d\xd9\xe5\x59\x56\x66\x36\xd8\xe6\x61\xa5\xd0\xb1\x1b\x64\x71\x7d\xa5\x55\xe0\xaf\x89\xeb\x3c\xb3\xfb\xa2\xcb\xa8\xc3\x0e\x0e\x1c\x62\x3f\xa2\x1b\x56\x28\xed\x75\x44\x8d\xe5\x6f\xf5\x11\x88\xb0\x32\x82\x0c\x36\xa6\x09\x53\x22\x8e\xba\x1d\x68\x15\x4f\x4d\x5a\x47\xa9\x1b\xab\xe6\x63\xc8\x0e\xa6\x76\x03\x17\x8a\xa7\xae\xa0\x0d\x1d\x0d\xe4\xb3\x9f\xce\x2d\x1a\xc5\x93\x95\xdc\x62\xee\xa0\xeb\x2a\x56\x70\x1f\x8c\x30\xbd\x11\xdf\x4d\xf5\x51\x6f\xbb\x1d\xe1\x82\x9a\xf9\xe6\x6a\x63\xf1\x14\x9e\x0e\x13\x4d\x7a\xab\x88\xfb\x52\x5a\x58\x50\x43\x6a\x41\x72\xe9\x6b\x63\xe0\xce\x00\x25\x11\x36\x8f\x78\x69\xab\x1b\x4e\x4f\x13\x11\xd3\x19\x4c\x8b\xb8\xb1\x98\x68\x0a\x49\x8d\x85\x5a\x3c\x74\x94\xb0\xdc\x5b\x28\xdc\xbc\x9a\xf9\xd2\x07\xd1\xca\xe3\x09\xc4\x61\x69\x8b\xf0\xd0\x4d\xb4\x51\x41\x42\xa7\x93\x72\x80\x12\xd5\x4e\xfa\x8b\x45\x48\xd9\xe5\x2b\x01\xa6\x8a\x2d\x21\xaa\xcd\x98\x76\x09\x0d\xc3\x11\x55\x2d\x12\x49\xdb\x4c\x0d\x60\x18\x5b\xf7\x5d\x1a\xa9\xcd\xb7\xc7\x52\x62\xc6\xb0\x0e\xe1\x96\x98\x8d\xdf\xc2\xa2\xc9\xc3\x61\x10\x00\x3c\xd8\x05\x26\xca\xae\x1a\xca\x3e\xe4\x80\xd2\xed\xd2\x90\x2d\xcb\x5b\x42\x09\xd0\x7e\xe9\x3e\xfe\xf6\x9b\xbb\xea\x61\xbd\x0c\x6b\x35\x1e\xca\x5c\xa3\xa6\x03\x71\x86\xec\xb5\x68\x9a\x81\x40\xe8\xf8\x39\x18\xa1\xc0\x63\x58\xc4\x40\xe0\x0a\xed\xbc\xdb\x28\xf6\xea\x2b\xcc\xf0\xf0\xd3\xe5\xac\x71\xce\xc7\xfa\x05\xd4\xa4\xbe\x1d\xea\x17\xb0\x85\x01\x23\x1d\x40\xc4\x4c\x3e\x94\x03\x52\xb6\xfc\xc1\xfc\xef\xc7\xe8\x07\x75\x8c\x3f\x88\xfb\x0d\xb9\x6a\xc8\xfe\xb2\xd2\xde\x80\xef\x7a\x06\x37\x94\x0e\x30\xae\x5a\xce\x5e\xab\x71\x63\x82\x1e\xe7\x6c\x12\xf4\x81\x77\x92\x9e\xf8\x23\x77\x64\x43\x2f\x26\x64\xf3\x98\x0c\x5b\x9a\x28\x8b\x92\x6c\xb6\x6d\x4b\xe2\x53\xeb\x1b\x43\xdd\x8c\x59\x6e\xee\x0e\x0a\x83\x11\xc9\xc8\xbb\x79\xe0\xe7\x6c\x8a\xa8\x39\x68\xdf\xd8\xd6\x69\xe2\x9c\xad\xc5\x6a\x2f\xf4\x5a\xe6\xbf\x86\xe2\x7b\xc6\x62\x77\xb1\x11\x74\x75\xda\xa5\x9d\xac\xa2\x61\x28\xf0\xfc\x04\x1f\xb6\x61\xe4\x21\xe2\x88\xc0\x66\x78\xdf\xfa\x47\xb9\x44\xf1\x7f\xb8\xc4\xff\xe1\x12\xff\x87\x4b\xfc\x3f\xe5\x12\xee\x60\x60\x4e\x9f\xbc\x26\x1f\xfe\x11\xfb\xb1\x3f\x63\xff\xc8\xba\x42\xca\x99\xbc\x29\x18\x90\xf0\x47\x5c\x85\x8c\x40\xf9\xdf\xe2\x12\x7f\xe1\xa5\xff\x23\xde\xff\x3b\x2e\xb1\x4a\xce\xd7\x72\x66\xaf\x40\x06\xf4\x47\xec\x6f\xfe\x8c\xfd\x81\x28\xb8\xc3\x1f\xff\x73\x3e\xc7\x17\x1e\xcb\x77\x1e\xa7\xfb\xdf\xe1\x12\x7f\xe1\x99\xc2\xff\x88\xf7\xff\x0d\x97\x18\x6a\xf8\xad\x8c\x3f\xb8\x44\xfe\x17\x97\x30\xff\x8b\x4b\x40\x87\x1e\xe8\x2b\x4b\xc3\xe7\x52\x86\x91\x3d\x2d\xbf\x40\x79\x16\x28\xf4\x3a\xd3\x13\x1e\x23\x49\x64\x01\x45\x47\x28\x28\xc1\x6e\x06\x38\xc0\xf2\xfa\xa4\xe9\x5d\x89\x67\x5d\x4e\x53\x95\x60\x50\x84\xa8\x83\x22\x6d\xec\x33\xe8\x1c\x11\x04\xc0\x11\x98\x1e\x55\x84\x68\xf4\xaa\xab\xbe\x33\xbe\x66\xf2\x37\xcf\xf3\x6f\xfc\x05\x62\x10\x4e\x3b\x6a\x5c\x25\x92\xf7\xca\x5b\x7d\x6e\xa8\xb3\x0c\xf4\x49\xcc\xb7\x10\x7d\xdb\x4f\xf0\x51\x01\xa4\x10\xa0\xe4\x4f\xb4\x80\x9b\x54\x47\x23\x3f\x24\xa0\xb2\x55\x7c\xb2\xb2\x74\x2a\x3a\x70\xde\xed\x91\xb0\x4c\xf6\xb8\x61\x2a\xe2\x9d\x82\x3e\xd2\x0d\xda\x57\x32\xe9\xfd\x6e\x8f\x43\xd0\x14\x35\x77\x75\xaf\x4f\x5e\xe5\xa5\xe4\xb7\x5d\x84\xd0\xb2\xff\xce\x8b\x6f\x88\x4b\x56\x23\x91\x59\x7f\x22\xc8\xfc\x9e\x0a\x5c\xba\x79\x27\x80\xe4\xf7\x2e\x1b\xd7\x05\xec\x65\x5a\x16\x40\x8a\xbf\xd8\xe8\xe7\xa8\x80\xa2\x57\x61\x2c\xc7\x86\x4c\xcc\x9c\x29\x65\xdb\xbc\xcf\x7e\x90\xfd\x1e\xc7\x3d\xd9\xd2\x11\xa1\x1a\x8d\xe2\xf9\xd7\xbd\x8a\x47\x8b\x9d\x8b\x25\x1a\xc5\x4b\xd6\xee\x6e\x64\xa0\x17\xc2\x8e\x4c\x98\x3a\xc2\x66\x61\x1b\x20\x5b\xbd\xf9\xa5\x36\xab\x9e\x89\x49\x3b\xab\x90\xdd\x6e\x5b\xd9\x59\x44\x02\x0d\x70\x29\xeb\x10\x76\x86\xab\x75\xb1\xa3\x69\xca\xb4\xe5\x6c\xe0\x80\x5d\x8c\x5f\x73\xcb\x59\xae\x84\x21\xf7\x20\x7d\xf9\xd3\xc4\x7b\x22\x48\x3f\x45\xd6\x71\x2c\x6d\x47\x6a\x90\x42\xc3\xe5\xb6\x52\x02\x23\xcf\xd2\x4d\x0b\x69\x65\x26\x9a\x8e\xe7\x5e\xd4\x30\x93\x58\xe0\x1a\x4d\x41\x1a\x85\x7b\x16\x87\x11\x76\x47\x39\x56\x93\x93\x23\x6d\x6e\x8c\x05\x82\xb3\x9f\x9f\x80\xbd\xa8\x7c\xf9\x79\x78\xad\x7a\xc6\x2d\x2c\x4e\xb4\xa8\x4c\x49\x67\x90\x87\x7f\x68\xd6\x91\x5b\xc0\xb1\x98\xb4\x59\x00\xb5\x83\x7b\x52\x60\x29\x61\x32\x92\xf2\x67\x2b\x32\x92\xb8\x29\xf4\x22\x5a\x0a\xec\xe1\xc7\xca\x33\x72\xc1\xd3\x6a\x48\x0f\xc4\xfb\x99\x8b\xce\x5f\x7d\xd7\x92\xa0\x96\x6f\x2e\x0d\xe5\x02\xde\x42\xd7\xf0\xef\xf5\xe8\x5f\x83\xbd\x9d\xe0\x5d\x4b\x9f\xb6\x75\x89\xd1\x16\x53\xe9\x2a\x52\x56\x4d\xe6\xe9\x8a\x6d\x59\xc4\x75\x37\x5d\x92\x65\xae\xf0\xf3\x5d\x57\x10\xca\x99\x32\x2a\x35\xf7\xc2\x14\x37\xc8\x59\x2f\x4d\xe1\xd9\x44\x3d\x73\x6e\xa1\x16\x6b\x86\x73\x66\x18\x90\xd9\x48\xf3\xb4\x1c\x35\x7c\xcc\x6b\xf6\xe3\x6c\xe9\x2b\xe4\x33\x20\x77\x30\xde\x72\x05\x62\x21\xdc\x71\x5f\x3f\x63\xa0\x7d\xcb\xae\x7f\x40\xdd\xe9\x2a\xa7\x8b\xc9\x0f\xf5\x53\x4f\x33\x0b\x85\x04\x32\xf5\x8e\x9c\xc9\x36\x00\x7f\xd8\xdc\x06\xa3\x8f\x93\xc0\x6b\x50\x2d\x18\xc6\xb8\x8d\x6c\x27\xa2\x40\x2b\xff\xd9\x5e\xa4\x7d\x1b\xff\x55\x54\xa2\xfd\xef\xc3\xd8\xa8\xa1\x38\xfe\xd3\x88\xff\xfc\x80\xf4\x8d\x8d\x61\xc9\x60\x93\x75\xad\xcc\x1b\x56\x9f\x15\x10\xd4\x6e\x53\x04\x2f\xb6\x11\x79\xf1\xf2\xbc\x18\x3b\x28\x25\xd1\x83\xc5\x47\x71\x5d\x36\x4e\x47\xd1\xa1\xa5\xb0\xe4\x05\x53\x69\x25\xf5\x19\xf8\xfd\x46\xa6\xb9\x4a\x67\x83\x42\x7f\xa7\x99\x8e\xd6\x64\x2e\x7c\xfb\x8d\xdf\x87\x96\x20\xfd\x5d\xa8\xb7\xdc\x0f\xc5\xb5\xe0\x36\x26\x1a\x12\x1b\x68\x21\xa8\x7b\x2e\x43\xc0\xd6\x87\xe0\xaf\x24\xc0\x93\xc8\x4c\x98\xca\x49\xd7\x10\x7d\x80\xce\x96\xdd\x06\x85\x07\x80\xb2\x0a\x5c\xcf\x9b\xec\x51\xc2\x1e\x35\xc1\x60\xbe\xe2\xd0\x54\x34\x93\xc4\x6c\x32\xe4\x3e\x84\x4a\xe0\x2e\xa4\xee\x18\x8c\xdf\x1a\x45\x2b\xd1\x86\x4a\xd1\x09\x03\x62\x30\xd6\x9d\x07\x51\xbf\xec\x0f\x14\x74\xe2\x12\x6d\xea\x2a\x19\x0f\xce\x9b\x9f\xc5\x6f\x78\xa6\xd8\x4b\x46\x21\x4c\xc4\x36\xe0\xf8\x6a\xba\x21\xc3\xb6\xb1\x82\x19\x1d\x5f\x7a\xac\x7f\x12\x5c\x9c\xe2\xc8\x66\xd1\xda\x69\x4f\xa6\xd8\x9e\x9e\x10\x5c\xc6\xd1\x68\xd3\x38\xfd\xdb\x39\xa9\x3b\x54\x8e\xf7\xe9\xee\x72\x49\x99\x5d\x74\x91\x7e\xe0\x75\xe6\x45\x02\xbb\xb4\x84\xc6\x5e\x56\xdb\x65\x66\x93\x41\x40\x42\xaf\x77\x26\x3e\xd7\x49\xfe\xea\x95\x12\xf1\x35\xe2\x0f\x60\x33\x8d\x15\x51\xba\x5e\x96\xee\xb2\x8c\xb8\xcb\x04\x50\x14\xe4\x16\xc6\xb2\xf1\x39\x2c\x7d\xda\x2b\x17\x07\x56\x87\xa6\xe9\x1c\x22\xb9\x7e\x64\x48\x40\x00\xfd\x91\xd9\xc0\x20\x4d\x2d\xd3\x85\x2b\x52\xad\x85\x8b\x78\x58\x61\xa3\xc3\x88\xf4\x79\x6a\xc0\x26\xee\xef\x38\x7c\xbb\xf3\xfc\x8a\xcc\x99\x20\xac\x2d\xa3\xc1\xa5\x50\xe3\xab\x57\xfa\xe7\xa0\x35\x23\x7e\x27\x6d\xb7\x04\x10\x19\x75\x3f\x12\xe0\x2a\xb1\x65\x8e\xf4\xb9\x36\x3d\x94\x33\xba\x7d\xf4\xe2\xd7\xf0\xb6\x41\xca\xda\x8d\x55\x49\xa6\x6c\xd2\x4c\xce\xeb\x52\xf0\x11\x72\x85\xb4\x61\x8f\xea\x23\xcd\x51\x60\x75\xed\x65\x93\x19\x1a\x24\x87\x54\x5e\x4c\xbc\x1f\x40\x41\xc0\x26\x71\x51\x95\x2e\x60\xea\xd2\x2c\x43\x0a\xda\x5f\xfc\x00\xbb\xfb\x8b\x11\xa2\x8d\x71\x20\xcc\x1e\xbf\x72\x3e\x38\x49\x36\x3b\x8b\xf9\xa2\xb4\x11\x34\x07\x77\x0e\x7c\x54\x36\x7d\xe9\xf3\x2c\xf6\x1c\xbf\x70\x5f\xc4\xba\x7d\xcc\x4b\xb7\x01\x52\x12\xc6\x6a\x86\x30\x0a\x04\x60\x7c\x62\xf0\xcb\x21\x7e\x15\xcd\x75\xf0\xbf\x29\x9d\x6a\xf1\xf8\xaa\xbb\x95\x93\xa2\xbe\x83\x84\x31\xd2\x29\xcc\x52\x67\xd4\x45\xf9\x9f\x4c\x03\x8e\x26\xfb\x57\x99\xee\xff\xcd\x41\xef\x08\xae\x21\x88\xa2\xbb\x52\xb7\xe6\x08\xb2\x1a\x12\xa1\x16\x9e\xe0\xf8\x79\xa0\xdc\xf3\xf2\x3d\x2b\x5b\x5c\xd5\x5a\x09\x36\xa4\xd9\x4b\x53\xf8\xe0\x3d\x9a\x3e\x4c\x0e\x8a\x96\x0b\x13\xd7\x8a\x41\xa2\x49\xe1\xa1\x43\x2e\xd2\xe8\x87\xc9\x8d\x68\x0a\xa7\x28\xf0\x79\xcc\xb8\xcc\x53\xf5\x59\x15\x68\x01\x34\x89\x5e\x57\x2a\xec\x2f\xa6\x26\xf3\x56\xda\xc6\x49\xb8\x83\xe7\x24\x0e\x42\xab\xc2\xc0\x02\x76\x5a\xfc\xf6\xf1\x77\xd8\xad\x33\x22\x68\x98\x16\x14\x78\xfc\x68\x05\x7e\x0d\xb9\x81\x04\x86\x92\x7f\xac\x01\x61\x63\x28\x32\xed\x92\xa0\x54\xed\x79\xbc\x13\x9a\xe8\x5a\x6b\x21\x25\x91\x5a\xf1\xa4\xf2\x48\x5c\xf0\x93\x8f\x5b\x80\x56\x7a\x81\xae\x48\x28\xa6\xfd\x8f\x00\x1a\xa7\xb9\xf7\xb9\xfd\x24\xff\xdc\x08\xb3\xdd\x89\x21\x49\xb7\xb8\xbf\x75\x48\x12\x5b\x61\x44\x03\x02\xb2\xea\xf9\x8e\x76\x58\x92\x8e\x5f\xa0\x99\xee\xae\x0d\x6b\xa5\x28\xec\xaa\x29\xee\xa1\xc0\x2a\x59\xc4\x64\x1b\xbb\x6d\x01\x1a\x56\x1b\xdf\x38\x3f\x70\xa9\x24\x21\x5f\xcc\x64\xfd\x27\x2a\x0b\x6b\x5c\x73\x03\xbf\xab\xa2\x59\xdb\x64\xa3\x90\x14\xa1\x96\x22\x14\xdd\xb4\x5c\xdf\xf8\xb8\x2f\xee\x36\x8c\x78\xf3\x02\xa3\x58\xfc\xc0\x15\x93\x62\x94\x9d\xa3\xef\x66\x19\xdd\x46\x5a\xaa\x63\x43\xad\x9f\x10\x1c\x70\xc6\xb6\xda\x86\xc6\xdd\xfc\x68\xc9\x26\xd2\xaf\x93\x6f\xae\xb2\xed\xc6\x0b\x40\xd2\xfb\x62\x64\xae\x35\x41\x14\x7b\xfa\xc1\x0b\xa6\x80\xdf\xe5\x71\x6e\x0e\xe3\x4f\x38\x24\xc2\xe1\x6c\xe7\xae\x54\x09\x37\x25\xc7\x69\xde\x85\x54\xbd\xf3\x97\x42\x8f\x65\x7f\xd2\x17\xc3\x33\x6f\xd7\xea\x42\xfe\x8b\x98\xb4\xb5\x96\x70\x45\x3f\xa2\xdb\xd8\xa0\x63\x61\x06\x9b\x85\xfa\xe6\x84\x3d\x1f\x74\xd0\xc0\xfc\x46\xc0\x67\xbc\xe7\x1f\x60\xf1\x85\x6f\x85\x4b\x6a\xa2\x0f\x8e\x92\x09\x23\x63\x58\xa8\x9b\xbe\x07\x32\x03\x30\xd2\x82\x44\x00\xc6\x45\x78\xb3\x9b\x67\x17\xe4\xec\x08\x5f\xaa\x7d\x82\x31\x99\xe7\x77\x3d\x14\xd9\x24\x9c\xc4\x3d\xb1\xa0\x85\xea\xc5\x45\xe2\x2e\xa1\x55\x0b\x5f\x26\xa8\x62\x16\x4f\x58\x25\x16\x70\xd4\x02\x49\xa8\x1f\x93\xbe\xa4\xcb\xb7\x42\x77\x82\x33\x5d\x22\x1d\x13\x62\x4b\x8a\x18\xd8\x25\x2f\x20\x15\xba\x65\x78\x63\x2d\x34\xd2\x6e\x43\x5b\x69\x5a\x53\x0c\xb1\x9d\xa4\xad\xe1\x10\xc2\xf9\x0d\xc2\x73\x84\xe4\x60\xc3\xad\x35\x6c\xfb\x85\x02\x24\x64\xd5\x10\xeb\x0e\x48\x58\x2e\x61\xb6\x4b\xd3\x5e\xcf\x84\x0b\x2d\x0b\xd8\x06\xd4\x9a\x29\x40\xd7\x88\x67\xf7\xe9\x2d\x6d\x5f\x75\x7d\xee\x56\x75\xd8\x33\x47\xd0\x08\x8e\xab\x91\x49\xdb\xd1\x96\x36\x93\xb3\x16\xa5\xcf\x33\x7a\x76\x34\xa2\xce\xdd\xcc\x99\xf2\x8b\x28\xc7\x68\x79\x1c\x43\xae\x20\x7f\xc0\x08\xa3\x27\x72\xdf\xb0\x0b\x53\x0c\x86\xb5\xb6\x0e\x15\x7a\x32\x67\xfe\x7c\x0d\xf8\xcf\x69\x07\x8f\xe6\xfb\x77\xb9\x8e\xbf\xf7\x2b\xfd\xa7\x03\x39\xb1\x73\xe3\xf3\xfc\xba\x3c\x94\x59\x3c\x86\x61\xed\xb2\x38\x8c\x96\x13\x11\xdd\x40\x98\xc1\x7d\x21\xd4\xb3\xd1\xc1\x45\x06\x99\x1a\x60\x61\x9a\xa2\xba\x1a\x83\xfa\x42\x14\x5c\x27\x70\x4d\xd6\x73\x4a\x3e\x1a\x75\xc7\x44\xc6\xfd\xac\xa8\xb9\x4a\xf7\xf4\x2a\x48\x71\xb1\x7e\xfc\xfe\x19\x24\xfe\xcd\xb5\x35\x85\xd3\x74\x04\xc9\x7b\xfd\x5e\x00\x40\x89\xb7\xb6\x2a\x0f\xde\xb6\x8f\x3f\x2e\x19\xb1\x49\x82\x59\xed\x31\x42\xf9\x5f\x8e\xec\x72\xf5\x80\x67\x51\xc8\x11\x53\xe6\x69\x8c\x42\x83\x85\x00\x2c\xba\x77\x26\xfa\xb5\xfe\x2c\x9f\x0e\x41\x00\x34\xde\x61\x08\xda\x7f\xe2\x67\x85\x63\xcf\x96\x9a\x95\x9a\x72\xf6\x5d\xa1\x4f\x56\xf8\x2d\x02\x5e\xca\xf6\x74\x97\xaa\x00\xaa\xc2\xf0\x94\x47\xc8\xe0\x52\x3e\xa6\xdf\xe2\xd8\xe1\x1d\x56\x6f\x7e\x70\xcd\xc5\xe7\x07\x2b\xed\xea\x07\xdf\x6a\x8d\xfa\x40\x1b\x56\x0a\x77\xc4\x3c\x3f\x57\xd0\x14\x4e\x16\xf6\x25\x49\x62\x23\xbe\xc6\x22\x9a\xb6\x53\x6f\xa6\x84\x84\x5f\x6e\x90\xc0\x02\x62\x06\xc6\x6d\x74\x23\x5d\x67\x83\x37\x56\xc9\xfc\x84\xa4\x82\x4a\x69\x25\xe4\xfb\x9a\xe4\x35\x97\x39\x38\xaa\x69\x63\x16\xb9\x41\x76\xac\x37\x11\xec\xcf\x53\x6f\x07\x61\x09\xdc\x9f\x70\x33\x95\x50\x71\x6f\xbb\x89\xb8\x73\xc3\x54\x67\x2c\x5f\xe5\xe5\x36\xb4\x43\xd9\x16\x84\xb3\x1a\x17\x51\x0a\x66\x3d\xee\xfe\x2a\x9a\x85\xe8\x48\xb2\x6b\x7a\x61\x0a\xf9\x2d\x4f\xa8\xc7\x51\xe1\xf0\x76\x03\xbd\xed\x58\x85\x00\x24\x3a\xad\xd1\x22\xf7\xbf\xee\xfc\x14\x7e\x98\x64\xcf\xdc\x04\xce\x17\x1b\xc7\x2b\x84\x22\x39\x0b\xc4\x64\x28\xbf\x28\x93\x3b\xe6\x01\x69\xd0\x40\x3f\x09\x4d\xe0\x24\x91\xe8\xa7\x9c\x65\xc7\xf0\xd4\x42\x2c\x8c\x8b\xb8\x2e\x37\x39\x46\xdf\xed\x28\xa7\xbc\x70\xe7\xad\xf6\xeb\x71\x71\x2b\xfa\x71\xf5\x32\x4d\x8b\xb1\x2e\xa0\x86\x37\xb5\x66\xa7\xde\x41\xdc\x8a\xbd\x5c\x4c\x33\x34\x24\x3a\xed\xec\xb1\xc9\x31\x8b\xe0\x00\x38\x80\x9c\x64\x13\xdd\x1d\xb5\x92\xb2\xa8\x73\xf9\xd4\xd7\x53\xb1\x17\xe1\x42\x6b\xfa\x3b\xdd\x5d\xb9\xa7\xdf\x76\xf0\xd9\xba\x69\xab\xac\x62\x08\xda\x9c\x39\x49\x43\x64\x2c\x0d\xb8\x92\xfb\x07\x89\xd9\xcd\x66\x36\xb5\xd8\x50\x60\xb3\x54\x25\x09\x8f\x6a\xf9\x13\x43\x5d\x25\x07\xaa\xa0\x9e\x60\x6e\xd6\x70\x29\x47\xde\x93\x72\x31\xe9\xa9\x04\x7b\x8d\xd5\x92\x20\x7a\x94\x6b\xf4\x55\x44\xfb\x63\xd0\xfa\x96\x53\x9f\x71\xc2\x23\xc0\xd4\xc0\xaf\x44\xfe\x57\x36\x7c\x39\x2a\xd4\xcd\x7c\xb8\xf3\x22\xda\xb3\xdf\x6e\xa5\x90\x8e\xc5\xa7\x85\xf5\x83\x52\x19\xdd\x90\x56\xe1\x59\x85\xfc\x36\x98\x38\xce\x01\x15\x4d\xfb\x61\x14\xec\x36\x81\x75\x58\x8a\x22\x59\x04\x2c\x51\x03\x5c\x28\x83\xc3\xc0\x9c\xfd\x40\x88\x0b\x21\xec\x5b\x31\x18\xad\x47\x6d\x10\x49\x02\xad\x49\xfe\x51\xb6\xd1\xd5\xff\x2e\xf1\xc0\xe4\xfe\xfd\xd8\xe6\x3f\x15\x84\x5b\xf2\xc9\xd1\x7e\x8c\xbf\x44\x35\x8b\x28\x10\xc6\x37\x50\xf7\xcc\x94\x5a\x9a\x85\x1a\x58\x5f\xa0\x8b\x16\x5e\x92\x12\xf2\x5f\xf8\xb0\x6d\x7c\xca\x5e\x3b\x21\x78\x22\xb1\xaa\xeb\xac\x4c\xc2\xf2\x42\xb4\x66\x82\x2d\xb4\xc3\x5e\x86\x6b\xfe\xf6\xdf\x55\x59\x98\x51\xa7\x3c\xe7\x47\x79\x76\x56\x75\x41\xa2\x84\xad\x7c\x9d\xc5\x90\xa4\x65\xcb\xc8\xab\x72\x85\x27\x95\x0d\x72\x0e\xbb\xc3\x68\x4b\x2d\x2e\x27\x48\x86\xbf\x83\xf1\xdc\xf5\x0a\xcd\x77\xee\x61\xb4\x26\x62\xab\xed\x1b\x4a\x66\x46\xc3\x57\x9c\xf2\x05\x75\x0b\xb8\xd0\x33\x09\x6c\x7f\x60\x64\xce\xcf\x81\x42\x03\xa0\xb5\x7c\x25\x8d\x00\xda\xfc\x3a\x31\xf0\xe9\x5e\x39\x9f\x8b\x84\xb9\x6b\x17\xa6\xd3\x26\x97\x40\x7e\xb1\x68\x7d\xf7\x9a\xca\x2f\x69\x35\x5e\x9e\xfa\x35\x24\xe4\x77\x39\x7c\xc9\x8e\xb7\x92\x66\xa7\x83\x9f\x75\x0b\x23\xc7\xdd\x2d\x01\x26\x00\x73\x12\xc0\xa6\xe2\x72\xa6\xc2\xef\x00\x7b\x20\xd4\x14\x7f\x0f\x15\x9a\x67\x4a\xd2\x44\x4f\x6f\x20\xdf\x30\xf7\x32\xdd\x1b\x37\x76\x23\x33\x89\x90\x28\x60\x37\xa7\xcc\xcc\x38\xf4\x16\xf6\x02\x3f\x48\x6d\xcc\x18\x59\x76\x22\xb6\x13\x0f\xd9\xc0\xc2\x79\x99\xc2\xc9\x0e\xb1\x67\x20\xd6\x96\x09\x33\xe9\xd6\xa2\x60\x6e\x45\x0a\x5e\x84\x0b\x55\x31\x55\xe6\x41\x1b\x5f\x95\xd9\x1e\xd4\xc7\x40\xc5\x90\x26\x75\xa8\x22\x25\xf2\x3e\x5c\x6b\x14\x7c\x2d\xdb\x1c\x7d\xf9\xd8\xc3\x79\x8f\x4b\x5a\xea\xe7\x2b\x3c\xb5\x43\x77\xf5\x54\x21\x0f\x49\x87\x51\x52\xb8\x36\x0c\x55\x2d\x3e\x41\x2d\x60\xa4\x01\x9b\xcb\x90\xab\x03\xfb\x0a\xce\x48\x1c\x3a\xb0\x9c\x8c\x02\x18\xc1\x9d\x8b\xed\x9c\xe4\x99\xaa\x15\xa0\xb7\x35\xd0\x83\xc9\x58\xc5\xbb\x12\xcf\xe0\x44\x1d\x58\x0c\xcb\xd0\xa0\xb4\x73\x6b\xa6\xc8\xf7\x8f\x12\xad\xd6\xa1\x10\xd4\xc2\xdd\x3a\x22\x88\x23\x90\x18\xbe\x35\x5f\xd4\x35\x5d\xbe\x2f\x4c\x0c\x96\xf5\xa7\x74\x28\x95\xe8\x13\x7f\xb7\x1c\xbd\xb6\x54\x56\xc3\x6a\x60\x47\xc0\x73\xc9\x8e\x76\x31\x25\xcd\x87\x8d\x43\xac\x42\x39\x7d\xca\xc8\x17\xd2\x5a\xd8\xc0\xdb\xd0\x46\xf4\xc7\xa9\x96\xf2\xf9\x21\xc1\xf0\x3b\xe2\xe2\xe7\x98\xf0\xbc\x39\x24\xfd\x0a\xf1\xed\x4f\x04\x3e\x2e\x6c\x86\x1b\x85\x81\x0b\x0e\x9e\xde\x49\x07\x33\x84\x3c\x86\x2f\x91\x05\x36\x94\xb3\xa0\x9b\x29\x01\xc0\x41\x7f\x72\x08\x0c\xc4\x45\xae\xec\x92\x66\xe0\xed\xab\x82\x45\x5b\xbb\xf1\xa1\x9f\x42\x8f\xbe\xa6\x01\x4e\xf0\xab\xc2\xfa\x74\xb6\xc1\xa0\x73\xce\x84\xdf\xfd\x17\x69\xf1\x53\x1e\x76\x73\x79\xc5\x1d\x30\x13\x4e\xc5\x29\x8e\x44\x30\xe1\xbc\xf6\xd1\xd5\x6e\xf0\x75\x38\x45\x49\xb9\xd0\xc1\xdf\x21\xdb\xfb\x75\x33\x1c\x76\x72\xf4\xd6\xce\x7b\x7a\xfd\xc3\xad\x08\xc7\xf3\xef\xea\x45\xa8\xd4\xff\x2e\x22\x04\xbf\xc3\x92\x60\xc1\xb1\xeb\xfd\x8d\xbb\xf7\x63\x9b\x53\x51\xbd\x97\x6b\x53\x96\x15\x44\x4e\x5b\x35\x59\x5f\x88\xaa\x59\x85\x9f\x39\x53\x9c\xdc\xc8\x54\x33\xa4\x4a\xe7\x7b\x4a\xac\xb7\x2a\x13\x71\xcd\xb0\x18\x8d\x6b\x78\x9d\xcb\x7a\x1a\x42\x7f\xd8\x4b\x03\x0a\x5c\x82\x32\xf7\x13\x73\xd4\xf0\xed\x79\xee\x87\x6f\x5c\x1d\xef\x9d\x13\xa0\xb6\x49\xa8\x96\x44\xa4\x71\x4e\xf6\xe5\x3e\x62\xac\xcb\x92\x0e\xce\x5f\x7d\xfd\x7e\x7d\xb5\x13\x24\x81\x54\x39\x7a\x7c\x0e\x41\x9f\xa2\x7a\xdb\xfb\x66\xd9\x1c\x60\xb0\xc2\xf4\x3c\x6b\xdb\x61\xc7\x18\xe0\x96\x34\xed\xd6\x97\xb1\x91\x5e\x00\x16\xbd\x28\x4a\xd8\x7a\x45\x57\x0e\xaf\x94\x52\x97\x4c\x20\xb3\x7c\x78\xda\x98\x29\x58\xb1\x57\x84\xdf\x33\xb5\x97\x89\x2c\x5b\x14\x0b\x24\x44\xdb\x7b\x7d\x67\x3e\xad\xaf\xf3\xeb\x41\x31\x1e\x48\xbc\x70\x32\x4f\x30\x2a\x23\x0e\xa8\xe7\x1d\x6c\x06\x94\xfb\x12\x24\x40\xdd\x2d\xde\x5e\x58\x0f\xa4\x23\x65\xa6\xc2\x18\xc4\xaf\xf4\x34\xd2\x02\x4b\xcd\x42\xfd\xe9\x11\xb2\xa7\x60\x54\x90\x25\x8d\x8b\x33\x46\x15\x9e\x13\xc4\x58\xab\xec\x18\x81\x87\xa8\x5f\xe7\xf0\xc8\xaf\xb3\x7e\xd5\xf3\xba\x4b\x52\xa0\xdc\xb5\x33\xb9\x2e\x31\x4c\x9f\x36\x19\x79\x35\xa9\x84\xa0\x91\xc1\x95\xec\xb5\x3c\x9a\x5a\xa0\x84\xef\xb2\xa3\xd1\x65\x19\xa2\xb2\x6f\x6f\x6e\x1b\x4f\x6d\x43\x52\xc0\x6b\xcf\x6b\x64\x96\x57\x2f\x00\x26\xed\x2f\x1a\x6b\x6d\xbf\xdb\xb5\xe3\x5c\x9a\xc8\x84\x80\x5e\x70\xc0\x11\xd0\x06\x59\xae\x30\xe2\x27\xc4\x2b\x10\x24\x67\x9d\x89\xba\x7e\xe1\x9a\x0f\x1e\xfd\x03\xca\xc5\xfe\xc1\x82\x15\xa5\x99\x03\xbd\xe2\xf2\x34\x88\x5d\xb8\xc2\xb2\x0b\x8c\x82\x9d\x57\xda\xaa\xeb\x27\x1a\x36\x50\x78\xb1\x9b\x6f\x00\x84\xa1\xae\x91\xcd\xd5\x07\x1c\x66\xa4\x19\x0a\x21\x99\x50\x03\xa5\x10\x26\x8b\x2e\x60\x2e\x26\x07\x42\xef\x43\xc2\x64\x55\xa7\x96\x97\x7f\x09\xca\x14\x2e\x66\xad\x08\x23\x31\xf8\x0a\x46\x28\xfc\xa3\x2b\xe8\x32\x1b\xef\xd7\xd2\xd6\xcd\xfd\xd6\x8a\x1b\xb6\x2b\x3d\x37\xff\xcd\xe7\xd5\xdd\x1e\xf0\x87\x70\xfd\x75\xdd\x0c\xcf\xa8\x1c\x48\x8e\x1f\xf3\x39\xd3\xfd\x4f\x86\xe1\x3b\xbb\xfe\x55\xa6\xb6\x8a\x7f\x67\xee\xff\x91\xf0\xd9\xf1\xb1\x6a\x79\x0c\xdd\x5b\xe0\x68\xa1\x63\x88\xa5\x12\x3b\xac\xc9\x39\xec\x0e\x11\x9a\x0d\xb0\x94\xc5\x4b\x2d\x60\xd4\x58\x0e\x62\xca\x2e\x09\x38\x36\x3c\x6d\x61\xb0\xbf\x61\x25\x13\xcb\x69\x58\xf7\xf2\x34\x89\x44\xeb\x6b\xff\x1d\x94\x75\x2c\xd9\x3e\x40\xcf\x54\x02\x39\xf9\xad\xcf\x77\x4d\x94\x80\x82\x85\xdb\xdb\xc3\xdc\xbd\xe7\x18\x41\xa6\xf8\x22\xea\xc2\x0f\x02\xd3\x9c\xd6\xb8\xc6\x2a\xbd\xa2\x3a\x65\xb0\x5b\x38\x62\x16\x9d\xc8\x4f\x56\x51\x6b\x7c\xba\x63\x21\x59\xa4\x66\xeb\x6d\xed\xf3\x61\xb0\xdd\x41\xd3\x35\xaa\xf1\x62\x51\x3b\x11\xa3\x10\xcb\xfd\x93\xd4\x68\x3c\xb3\xaf\x6b\x42\x0e\x0b\x22\x5a\x26\x93\xf9\x61\x8c\xc1\xb3\xb8\x2a\x53\xbc\x9b\xd6\x96\x56\xd6\x1e\x24\xc0\xab\x18\x3d\x03\x48\x71\xf9\xf3\xfd\xce\x71\xb1\xe7\xc0\xa0\xdf\x2a\xf6\x6b\xea\xc9\xe0\x79\x29\xda\xae\xb9\x8a\xb9\xd4\xa3\x4d\x9e\x9c\x96\x0b\x6f\x69\x93\xa7\x70\x83\x7e\x29\x82\x5f\x8f\x05\xff\x05\xc3\xa9\x62\xf6\x8b\x26\xbc\xba\xbe\x84\x23\xa9\x76\xf6\x6e\x2c\x60\xf6\x35\x80\xa1\xb1\x8e\x20\xd0\x01\x15\xb7\x95\x0e\xf5\xcf\x8c\x77\x36\xd8\xd2\xb3\xe1\x19\x82\xcb\xf5\x92\xe9\x98\x3b\xab\x06\x38\x0d\x68\x7d\xb2\x29\xb7\x25\x3c\x92\x92\x76\xe9\xe9\xad\x95\x16\xcb\x4f\x53\xb3\x30\x55\x5a\xb6\x91\x18\xef\xd3\x10\xf8\x06\xef\xfc\x37\x73\x03\x55\x9d\x31\x20\x18\x4c\x9f\x65\xe9\x69\xcb\xe5\x1d\x94\x72\x28\x26\xe3\x79\x4a\xb6\xc4\x59\xee\x7d\x27\x7d\x83\xff\x36\xeb\x2e\x0a\x77\x00\xd0\xe0\x81\x14\xe1\x9a\x8f\x69\x37\x25\x2c\x9d\x82\xec\xd5\xc1\x9b\xb9\x35\x39\x30\xeb\xb4\xf6\x35\x13\x4a\xdd\xec\xa6\xb9\xa5\xa6\x36\x15\x5c\x0d\xe6\x95\x5f\x5c\x1b\x18\xc3\x1f\x76\x4f\x50\x8f\xd9\xa8\x66\x83\x14\x8c\xd0\xc8\xee\xbc\xea\x8d\x4f\x75\x5b\x82\xcc\x63\x21\xe9\x94\x58\x60\x42\x3f\xc2\x21\x4f\x60\xda\x6f\xbb\xeb\xed\xc7\x16\xf1\x83\x85\x56\x9b\x4c\x98\xbb\x9b\x8d\x9c\xef\xaa\x68\xbd\xa9\xbf\x3b\xb0\x61\x02\x6d\xb1\xb4\x4b\x30\x0e\x62\x67\xf8\x80\xef\x88\xab\x71\xc7\x56\x2f\xad\x71\x23\x00\xf1\x2d\x0d\xb0\x89\xaf\xa2\x7a\x68\x26\x57\x6d\x67\x93\x48\xe7\xca\xb9\x6c\xce\xf1\xd6\x0a\x69\xac\x5a\x60\xe1\x62\xa3\xe5\xcb\x5a\x66\x44\x9d\x6f\xc9\x36\xac\x1c\xf8\xed\xe6\x68\xdc\x80\x4e\x42\x0a\xea\x4b\x20\x01\x2e\xdb\x2d\xaa\x45\x86\xd9\x8f\xb9\x05\x66\x3e\xfa\xc4\xee\x82\x20\xa2\xe5\x16\xcb\x11\x97\x1c\xe8\x9e\xa6\x5a\x13\x25\x9f\xe8\xa1\x6a\x89\x39\xd0\x4a\x61\xca\xd0\xd0\x67\xe0\x0c\x2e\x20\x47\x34\xb7\xf2\xb8\xb4\x4f\xd5\x8e\xa5\xf3\x90\xee\x95\x0f\x59\xea\x1f\xcc\x6a\xd7\x55\x92\x12\x5d\xba\x1c\x05\x8d\x59\x05\xc9\x9f\x75\x00\x45\x14\xce\xbf\xff\x1f\x73\x5f\xde\xe3\x28\x92\xed\xfb\x7f\x7f\x0a\x94\xad\x79\x3d\x23\xb7\x81\x60\x27\xab\xaa\x75\xb1\xc1\x2b\x78\xdf\xf0\xd3\xd3\x15\x66\xb7\xd9\x0c\x18\x0c\xf9\xea\xbb\x3f\x45\x60\xe7\x52\x99\x39\x3d\xf3\xa6\xae\xd4\xea\xae\xb4\x1d\xcb\x89\xb3\xfc\xce\x2f\x02\x12\xe7\x59\x8e\xe5\x54\x1b\x55\x27\xdf\x29\x27\x9d\xa4\xeb\x2a\xc4\x5a\x0a\x02\x65\x77\x71\x42\xf9\x22\xec\x03\xc7\x29\x8a\x50\xd8\x2d\xe7\x22\x89\xfe\xc6\x11\x99\xf4\x78\x93\x14\x62\x66\xf6\x93\x6f\x08\x94\xe1\x27\xb4\xf2\xf0\x8a\x57\xb2\xc2\x6d\x5d\xc3\xe0\x8b\xe9\x19\x69\x66\xe7\xdf\x2e\xb9\x23\xfc\xfe\x37\xba\x9b\x15\x2e\xaa\x0a\xab\x1a\x95\x9d\xfe\x37\xf5\x1b\x76\x0d\x83\x28\xfb\xf6\x9b\x97\xe7\xc9\x23\x41\x94\x65\x89\x97\x34\x1e\xa7\x2e\x41\x91\x24\x09\xc5\xfc\x86\x15\xbe\x5d\x76\xe2\xeb\xb7\xdf\x48\x8c\xc4\x78\x0a\x03\x24\xf9\x5c\xd2\xb5\x0a\xec\x3f\x2b\x3d\x0b\xfe\xb5\xd2\xb3\x34\x87\x53\x4d\xe1\x59\x40\x82\xa6\xea\xec\xad\x09\xbe\xc3\x49\x92\xfd\xe9\x25\x67\x6d\xca\xb4\x6c\xe6\xe3\x9a\xa7\x1f\x94\x60\xb5\x49\xd3\xf8\xac\xc4\x2b\x0d\xe8\xf7\x25\x5e\x0f\x26\x69\x59\x1f\x8f\x67\x98\x0f\x4a\xc2\x52\x07\x60\x7d\xa2\x0e\xcb\xbf\x2f\xc1\x6a\xf2\xa2\x65\x7e\x52\x42\x96\x13\xdf\x57\xcc\x3d\x18\x02\x73\xf8\xac\x84\x2c\x78\x5f\xd2\xd6\x38\x70\x82\xf1\xc9\x78\x91\x66\xde\x57\x79\x35\x19\x56\x14\xfe\xc7\x4b\xc2\x6e\x44\x71\x80\x53\x1b\xe0\x31\xec\xc7\x75\x61\xc1\x9f\xd6\x85\x7d\x2f\xe2\xdf\x2d\x0e\xfb\xa3\x7c\x11\x07\x98\x08\x70\xa0\x32\x38\x8f\xf1\x14\xce\x7a\x34\x2e\x06\x14\x2e\x60\x80\x42\x35\xd3\x99\x36\x7c\xe3\x31\x38\x1b\xd0\x38\x8d\x01\x1a\xa3\x70\xb1\x0d\x68\x8f\xc6\x85\xa0\xcd\xe0\x1c\x06\x04\x9c\xf3\xda\x8c\x0a\x78\x8c\xe7\x71\x2a\x68\xd3\x38\x8f\x01\x1a\x17\x07\x22\x0e\xea\x90\xa2\x70\x80\x91\x1b\x24\x9b\xc5\xf9\x00\x55\x15\xa7\x70\xfe\x2e\x9b\x87\xad\x45\x23\x84\xc6\xd9\x0d\xcf\xe1\xcc\x4d\x06\x83\xf3\xb0\x8d\x47\x1f\xdb\xf0\x63\x71\x6f\xe3\x50\xc9\x70\x1e\x23\x83\x36\x07\xfb\xe0\x74\x06\x07\x01\x03\x35\xa7\x71\x01\x63\x9a\xa2\xf0\x82\xc7\xa8\x1c\x85\x4c\xf4\xda\x0c\xfe\x52\x91\xf7\x6f\x14\xed\x38\xce\x9f\xd6\x9f\xa6\xfe\x35\x12\x00\xc2\x9d\x04\x58\x12\x27\x29\xba\xe1\x81\x5b\x2b\xf5\xd2\xfa\x1f\x11\x41\xc3\x25\x3f\xe2\x91\xa3\x19\xf1\xe3\xf2\xd0\xef\xc1\xcb\x93\x80\xe6\x0e\xff\x14\xbc\x9f\x7a\x82\xfe\x17\x3d\x01\x70\x16\x80\x9b\x2f\x00\xce\x83\x5b\x25\x6e\x8e\xc5\x29\xd4\x4e\xbd\xb4\xff\xf5\xbd\xf1\x9c\x27\x1c\x83\xd3\x18\xcb\xe2\xac\x79\xaf\xbe\x8f\x6a\xca\xd3\x6d\x16\x07\xf0\x85\xc7\x69\x54\xad\x1d\xe5\x08\x84\x9e\x80\xb2\x87\x5f\x52\x22\xce\x61\x1c\x8d\x73\x18\x05\xfb\x38\xc6\x84\x33\x71\xaa\x99\xc1\xb5\x05\x9c\x6d\x53\xa8\x1e\x7e\x53\x76\x5d\x80\x49\xd0\x06\x6d\x16\xae\xc2\xa1\x17\x24\x0f\xae\x0a\xc7\x01\x1e\x6f\xea\xc8\x63\x54\x53\xff\xbe\xc9\xa3\x5b\x25\x78\xd0\x14\x9d\xc7\x39\x0c\xe6\x00\x8f\x83\x26\x15\x51\xe9\x7e\x8a\x6c\x03\x9c\xc5\xb8\xa6\x60\x3b\xcc\x41\xa6\x8d\xea\xb3\x8b\xe8\x0d\x87\x04\xe1\x14\xc6\xe1\x22\xaa\x45\x4f\xe2\x34\x46\x86\x6d\x11\x17\x31\xc0\xe2\xb4\x89\xb3\x4d\x89\x7a\x68\x2f\x86\x2a\xca\x53\xc8\x0d\x7c\x63\x3e\x14\x0b\x70\xaa\xcd\xa1\x66\x00\x70\x11\xf2\x04\x8f\x51\xa8\x08\x3c\x83\xe1\x0c\xc6\xe3\x02\x9c\x4a\x61\x0c\xd2\x80\x47\x26\xb1\x50\x13\xae\x4d\xe1\x7c\x48\x41\x3e\x00\x1e\xc0\x81\x09\x55\x61\x50\x4d\x79\xaa\xa9\x2c\xdf\x46\x75\xf9\xb9\x36\x80\x09\xde\x7e\xae\x46\x4f\x23\x3d\x3c\x80\xb3\x1b\x5a\x68\xaa\xcf\x93\x18\xaa\xa2\x7f\xb3\x02\xe7\xeb\x90\xc1\x48\xa4\x3d\x9c\x4b\x36\x5e\x42\xc1\x7b\x2d\x1f\xcd\x2d\xd0\x70\xa8\x3c\x8b\xd3\x1e\x2e\x9a\xef\x86\xb5\x01\xd2\x0c\xc6\x04\x15\xed\x47\x9e\x84\x8a\xb4\xa1\x85\x26\xce\xe3\x14\x8c\x0e\xd4\x0e\xba\xeb\x56\x5b\x1f\x7d\x68\xa2\xc4\xa1\x20\x34\x53\x68\xf4\x09\x40\x8d\xb9\xa6\xda\x3e\xd3\xa8\x8c\xb3\x78\x33\xe5\x56\xce\x1f\xfd\xcf\x41\xa4\x34\x62\x44\x68\x0b\xc4\x0c\xec\x15\x71\x06\xca\x82\x3a\x0b\x48\x61\x54\xb6\x1f\xe9\x47\x63\xe4\xad\xae\x3f\x80\xc8\x6a\xf4\x6d\x43\x25\xa1\xb5\x77\x20\x20\x96\x16\x20\xf8\x18\x13\x9a\x4b\x37\x61\x46\xae\x12\x71\x18\x4f\xae\xb1\xe8\x53\x55\xe8\x26\x58\x50\x30\x32\x8b\xc5\x28\xa8\x0b\x72\xf9\x2d\x0c\xf7\x21\x02\x9c\x86\x1a\xa1\x3b\xbc\x36\x2e\x36\x6b\x36\x6a\xd3\x6d\x04\x60\x80\xd8\x1d\x3a\x5b\x30\xdb\x10\xe7\x38\x68\xa3\x31\x54\x9b\x45\x7e\x85\x56\xc1\x8d\x84\x84\x98\x82\x1f\x40\x83\x7c\xd8\x42\xe3\x1c\x0e\x30\x16\x62\x4d\xa3\xe1\x20\x06\xe0\x9c\x89\xb3\x38\x85\x96\xa0\xee\x2e\xbe\x39\xaa\x51\x0f\x3a\x1b\x45\x43\x84\xca\x51\x4d\xb0\xa0\x93\x60\x64\x61\xd8\x0a\x00\xe1\x20\xa2\xc1\x54\x33\x07\x19\xf1\xe2\x4f\xc4\x0a\x48\x59\xf6\xe6\x5f\xd0\xe4\x65\x1d\xb6\x59\x9c\x86\x3a\x40\xcf\x40\xaf\x72\x30\x1d\x61\x72\x42\x48\x36\x61\x66\x9f\x85\xb5\x51\x5c\xa8\x67\x69\x28\x6e\xb8\x88\x5a\x1b\x07\xf3\xd0\xc1\x03\xc0\x9b\xa8\xa3\x89\xc3\xcb\x78\x06\xad\x4b\x35\x62\x68\x18\x3d\x24\x19\xbb\x73\x04\xca\x1a\x06\x03\x26\x0e\x30\x06\x06\x08\x13\x51\x74\x19\xc8\x14\x3c\x26\x60\x70\x2c\x54\x1e\x6e\xd2\x40\xc4\xa9\x36\x03\xb5\x63\xdb\x34\x2e\xe2\xa0\x2d\x40\x0d\x79\x98\xa9\x28\xd7\x1b\xb6\x83\xae\x45\x79\x02\xd9\x82\xae\x43\x38\x41\x78\x4e\x64\xb6\x89\x36\x85\x91\x50\x43\x98\x69\xac\xd9\x58\xff\xe2\x0b\xe4\x24\x44\x11\x26\x1c\x88\x21\xcd\x99\x26\xd9\xd0\x8a\x48\x0a\x0c\x6d\x1b\x09\x6a\xd0\xc4\x40\x97\xc2\x3c\x80\xce\x6f\x5e\x58\x04\xa3\x1b\x1c\x9a\xcc\x83\xcb\xb0\x68\x19\x06\x67\x30\x44\x9f\x50\x1c\xd4\x00\xc6\x58\xc4\x10\x4d\xe2\xd0\x5e\xc4\x47\x90\xaf\xee\xa0\xe5\xdb\x0c\x02\x22\x34\x5c\x68\xa8\x98\x46\xbc\x45\xe1\x74\x1b\xd1\x36\xdb\x24\xa1\x88\x0b\x90\xe4\x61\x16\x42\x08\x42\x15\x5f\xe9\xd9\x7e\xb6\x97\xbf\x41\x1c\xf2\x66\x63\x13\x83\x8b\x21\xc3\x20\x02\xa6\x1a\x9f\xd1\x77\xd6\x01\xf7\x34\x79\x21\x27\x68\x13\x53\x40\xa2\x83\xd6\x34\xe2\x20\xa5\x90\x05\xf2\x6b\x1b\x2d\xdd\x38\x1b\x5a\x4d\xd5\x21\x8f\xb8\x80\xf1\xa0\x0c\xd8\xd6\xd0\x24\x0e\x1a\x30\x22\x40\xb2\x88\xf5\xda\x00\xca\x7d\xa5\x02\x73\x87\x35\x7a\x79\x47\x39\x30\x76\x50\xce\x8d\x1e\x1a\x78\xf1\xd0\xe8\x9b\x65\xe2\x9d\x30\x58\x24\x4a\x68\xdf\x25\x22\xd7\x72\x0d\xae\x1b\xca\x60\x30\xb8\x38\xdb\x30\x28\xd7\xe4\x04\xfd\x4f\xa7\x0b\xcd\x74\xa6\xd6\x00\x8b\xb1\xbc\xf9\x3a\xf8\x3c\x4a\x06\x18\x3e\xa4\x33\x02\x29\x72\x3b\x8d\x98\x05\x6d\x20\x66\x13\x13\x06\x0a\x42\x00\x11\x91\x2b\x20\xbd\x21\x5e\x40\x2b\x35\xe8\x15\x9a\x19\x8d\xaa\x70\x83\x35\xc1\x7d\xac\x70\x1b\x2b\x3e\x53\x19\xf3\x8a\xca\x5e\x78\x1e\xc5\x8c\x37\xef\x44\x4f\x3f\xd3\x8e\x80\x22\x86\x21\xb5\xb9\x66\x87\xa3\xe1\x67\x08\xfb\xbb\xaf\x35\xc0\x61\x1c\x09\xc9\xf0\x96\x0d\x54\x1b\x31\x0c\x5c\x17\xc2\xb6\xd9\xf5\xb1\xe7\x5d\x11\x34\x47\x04\x13\x45\x18\x07\x37\xda\xa2\xa1\x1d\x2f\xf4\x05\xad\xbb\xed\x4f\x88\xc5\xe1\xfa\x8d\x29\xb8\x70\x67\x3d\xb8\x35\x09\x6f\xc8\x03\xed\x28\xf7\x36\x98\x8b\x08\x29\xb7\xad\x05\x61\x4e\xbc\x69\x08\x30\x24\x0d\x42\x50\x03\x22\xc6\x51\x0d\xfc\xe0\x72\x68\x4b\xe2\x9a\x70\x36\x41\x06\xb7\x1d\xa7\xe1\xe8\x9b\x19\x30\x99\x60\x46\xd0\x77\xa2\xa3\xdb\xb7\x4d\xe8\xbe\x61\xa3\x18\xde\x48\xf9\xe6\xee\x0f\x2f\xad\xe8\x97\x4b\xab\x4f\x0f\xb8\xcc\xbf\x76\xc0\x85\x57\x64\x9c\xd8\x1c\x70\x79\x06\xa7\xc8\xdb\x01\x97\x15\x70\x1e\xb5\x53\xdf\x7e\x13\x78\x9c\x27\xff\xd3\x03\xee\xfb\xeb\x7e\x47\xb4\x1d\x87\xfb\xe4\x42\x9e\x7f\x7f\xe1\xec\x08\xb6\xe5\xb0\x9f\x5c\x98\x83\xf7\xa7\x67\x87\xb6\x39\xe7\xe3\xd3\x33\xce\x01\xea\xfd\x8d\x05\xd3\x3a\xd8\x87\xcf\x2e\xe4\xdf\x0f\xa7\x4d\xf3\xb3\xfb\x10\x3c\xfb\xc1\x7d\x05\xfe\x20\x58\x9f\xdc\x27\x10\x3e\xb8\xcf\x61\x1a\x06\x30\x3f\xbb\x4f\xc0\xbf\x3f\xff\x1f\x4c\x41\x38\x7c\xa2\xbe\x48\xbd\x1f\x6f\xd8\x9c\x69\x7c\x36\x9e\xfb\xe0\x62\xc4\x61\x2c\xf1\xe3\xf1\x3f\xf3\xbe\x82\xd7\xa6\xf8\x0d\xf8\x18\xf7\xcc\x9f\xde\x52\x78\x33\xfb\xdf\xbd\x9b\x70\x6f\x80\xda\x1e\x63\x3f\xfa\xf6\xdb\xc1\x2e\xec\xe0\xd9\x8a\xac\x70\xff\x46\x2b\x0f\xff\xc9\x5d\xc3\x6b\xf0\xd7\xfa\x1e\x52\xf8\xa6\x08\x7c\xda\x53\x94\x39\x11\x1a\xe1\x9e\xd6\xa9\x16\x59\x0f\xbb\x94\x16\x0e\x57\xca\x69\xad\xbb\xca\xa2\x37\x57\xd2\x2b\xab\x08\xe3\x95\x0f\x0e\x84\xc7\x8b\x12\xc1\x2c\xb7\x74\xd4\x9d\xd8\xba\xeb\x76\xf4\xfd\x46\xd1\xd6\x44\x45\x4f\xe8\x3d\xaf\xf1\xd3\x95\x4c\xf4\xb9\xe0\x44\xa5\x97\x92\x22\xeb\x85\xb5\x26\x76\x1b\x11\x6c\x36\x7d\x32\x5c\xce\xc7\x04\x1d\x01\x83\x38\x9e\x2a\xce\xe2\x76\x19\xdd\x17\xb6\xbb\x65\x6b\x56\xb2\x13\x4e\xdd\x1d\x55\xb5\x7f\x89\x0c\x82\x17\xe2\xfd\xd8\x4e\xfb\x99\x3e\xce\x53\x59\x01\xdc\x65\xd4\x57\x81\x2a\xba\xca\x74\x6a\xea\x16\x65\xa9\xc0\x99\x94\xe9\x41\x25\x08\x63\x37\xe1\x47\xc0\x76\x66\x5a\x78\x5a\x9f\x95\x9e\x74\x22\x25\x72\xb3\x9f\x1c\x7a\x8a\x31\xef\x76\x32\x73\x78\xda\x1d\x45\x9e\xad\xe8\x89\x7a\x16\xaf\x95\x2d\xcc\x3a\x27\x29\xf2\x07\xd3\x5e\xe2\xb5\x8e\x94\xdd\x65\xd2\xcc\x8a\x3b\x8c\x9a\xf5\x2e\x87\x7e\x40\x0c\xce\xc2\x22\x2f\xf4\x6d\x72\x5d\xcd\x7d\x96\x8a\xc1\xb1\xd8\xfa\x7d\xdd\x58\xec\x55\x92\x30\x2e\xb2\x3b\x3d\x75\x89\xbd\xd0\xd1\x55\x6a\x76\xbe\xfa\x56\x02\x7a\xfb\x93\x17\xcb\xd7\xc4\x36\x76\x12\xb1\x3e\x5e\x8e\x04\x33\x88\xa7\xd7\xf1\xf8\xe8\x4f\x7d\xfb\xc4\x2f\xd6\x4b\x6f\x31\x99\x6f\x8d\x89\xde\x9b\x5f\x34\xc3\x49\xf5\xee\xd5\x2f\x99\xb8\xde\x8f\x9d\xf3\x41\x1f\x91\x4a\xb1\xb0\x02\x20\xcf\xab\x6a\x95\x09\xbb\xee\x64\x25\x71\x6b\x45\xd5\xca\x42\xae\xd4\x64\xbf\x1d\xee\x27\x93\x60\xa2\x06\xf3\xe9\x98\x52\xb5\xd1\x62\xd4\x62\xa5\xd3\x65\x0f\x96\x7c\xb7\xd7\xab\x47\xf5\x89\xe5\xfa\xd1\xfa\x38\xdf\x06\xfa\xe9\xdc\x8d\x3b\xdb\xde\x21\x8e\x94\x8d\x6e\xaa\xaa\xc4\x58\x93\xa8\xc3\x51\x4c\x7f\x9e\xc9\x9d\xed\xd0\x75\xf6\x23\xc5\xbd\x9e\xe2\xae\x57\x2f\x7b\xdb\x22\x62\x36\xc9\xdc\x0e\xe5\x90\xda\x94\xbb\x79\xb6\x1b\x95\x3d\xe0\x71\x66\xcb\xbd\x06\x73\xf6\xe8\x2e\x7d\x65\xad\xe4\x64\x69\x0d\x6d\x3e\xd7\x94\x65\x2b\x52\xfa\x94\xd1\x55\xfd\x91\x36\x1d\x0e\xb7\xc3\x54\xb4\x49\x59\x51\x54\x49\x5b\xa7\xe5\xe2\x62\x7a\x1b\xa9\x5a\x8d\xfd\x70\x5d\x4e\x79\x76\x14\x72\x9b\x1e\xdd\x29\x78\x3f\x9c\x1a\xc7\xd6\xd5\xe2\xd7\xbd\xf1\x66\x49\x74\x66\xa3\x1e\x38\x10\x0a\x93\xbb\xab\x54\x61\xc4\x11\x47\x4e\xd9\x93\x69\xc7\x93\x73\x5c\xfa\x97\x8b\x3e\x36\x04\xd7\x1b\xec\x24\x46\x58\x8b\xda\x8a\x92\xe6\x6e\xb5\x28\x56\x2b\x4f\xa1\xc9\xc3\xdc\x37\x96\x7d\x83\xa9\x54\x6d\x34\xe9\xc5\x2d\xf9\x4c\x50\xe6\x20\x67\xba\x7a\x50\x56\x3d\x87\x5a\x72\x9d\x41\x59\xa6\x5a\x49\x18\x85\x7c\x58\xb0\x5d\x70\xe2\x3d\xa0\xcf\x99\xf1\x80\x96\x42\xa7\x25\x99\xfb\x4a\x39\xec\x67\x85\xd8\x1d\xe6\xf5\x5c\x06\x81\xa8\x1c\x72\x7d\x7a\x2c\x78\xa6\x20\x2c\x7a\x2a\x2e\xb4\xd9\x4a\x4e\x33\xa5\xec\x0f\xb7\x13\xe1\x4c\x55\x27\x7e\x37\xd1\x17\x99\x38\x4a\x17\x05\xbd\x61\xa4\x8e\x24\x2f\xfb\x0b\xce\x9e\x93\xc4\x64\xfe\x33\x7f\x5f\x79\x0d\xb2\xeb\x5f\x8b\x23\x82\xd7\x7f\xa7\xf0\xdc\x53\x94\xf5\x6c\xb3\xb3\x66\x3a\x71\xb1\xb7\xfb\x61\xec\xeb\x7b\x7f\xa9\x8f\x75\x6f\x64\x72\xca\xc1\xba\x0c\xa6\x9e\xeb\x1f\x63\x3a\x27\xca\x01\xa8\xb9\x0e\x39\x92\xbc\x69\xa5\x0d\x55\xef\x1a\x33\xa7\x51\xff\x04\xa4\xe5\x4a\xba\x96\xdb\x1e\xa9\x25\x09\x6b\x0d\x4c\xb1\xe8\xad\x6b\xbd\xf4\x2d\x23\x3e\x87\xe7\x96\x20\xb2\xe2\xb5\x3e\xd4\xfd\x7c\x62\x5e\x39\x71\xb6\x5a\x52\x9c\xb2\x0a\xe7\xf9\x52\x4c\x99\x41\x45\x5c\x0b\x5e\xdb\xf2\xc7\x4d\x2b\xf7\xd8\xaa\xde\x98\x86\x3e\xdb\x11\xad\xd6\x30\x17\x2f\xcc\x44\x2a\x5a\xdd\xcd\x82\xcb\x3b\xeb\xf5\xea\xac\x8d\x32\xd9\x5c\xd4\xc7\xfd\x74\xaf\x09\x5b\x71\xaf\x8e\xaf\x2d\x62\x27\x1f\x18\x9b\x25\x4e\x03\x76\x18\x91\x41\x32\xd4\xb7\xfd\xb5\xd1\x25\xf5\xd5\x3e\xea\x74\x25\x65\x1c\x6f\x16\xb4\x4a\x73\xb1\x1c\xf3\x93\x43\xe6\x06\xfb\xf2\x70\x96\x39\x7f\x3e\x9e\xee\x7a\x9a\x39\x5e\x6f\x9c\xce\xa9\x23\xc5\x73\x2f\x90\xd9\xeb\x55\x93\x13\x62\x90\x2e\x0b\xfa\x0c\x46\xae\xbe\xa5\x6b\xf2\x4a\x8e\x77\xf5\xa9\xab\x8f\x8c\xc5\x3e\x38\xa6\x17\x8a\x36\x06\xdb\x55\xad\xfa\x46\x28\x55\x55\x5e\x90\x53\x71\xad\x5b\x0e\x3b\x93\xd2\x73\x90\x24\x1d\x47\x5b\x3b\x17\x26\x96\x54\x25\x3d\xef\x3b\x63\x73\x7d\xd5\x7a\x8b\xee\x40\x49\x48\xd9\xdd\xb2\x6a\xcc\x4c\xc4\xc9\x70\x02\xac\x1e\xb9\xdb\x65\x9b\xde\x74\x5d\xcd\x46\xab\x3a\x6e\x6d\x3b\xd2\x44\xf6\xad\x63\x22\xe4\xee\xa0\xdf\xa7\x4d\x52\x8e\x46\xcc\x65\xb8\x70\x18\x73\xda\xed\x18\x5b\x76\x7c\xd4\x85\xeb\x69\xaf\xf2\xd4\x35\x19\x89\x73\xb3\x57\xb3\x87\xcd\x79\xb0\x1e\xf5\x07\x7b\x95\xd2\xf3\x49\x38\xf6\x49\x4e\xef\x56\xfe\xa6\x77\x60\x32\xa2\x50\xc6\xda\x4a\x72\x40\xc2\xd8\xd6\xb4\xcf\x85\x9a\x0f\xea\x05\x57\x2a\x89\xb5\x2e\x77\xad\x42\x95\xf3\x53\xb7\x1e\xc4\x63\x3e\xc9\x4d\x8d\x33\x2a\x35\xec\x1b\xc7\x22\xb7\xaf\xcc\x2c\xf0\xab\x78\x78\xea\x2d\x8e\xe1\x5a\x91\x96\x76\xd0\xa1\xd2\xdd\x7c\xb1\x74\x8e\xeb\xee\x4a\x9c\x05\xdb\x24\xdc\x52\xc0\x5f\xf5\xeb\xae\x54\x29\xa7\xb5\x7f\x9d\x2d\xce\x3b\xcf\xa6\x36\x4c\x3d\x36\xeb\x83\x15\x56\x07\xf7\x94\x8c\x48\xb3\x3f\xbd\x48\x9c\x4e\x69\xab\x6e\x36\x8e\x7d\x76\x90\x4d\xc6\xfc\x84\xd6\x26\xad\x4b\xa9\x1b\xdb\xc3\x55\x77\x62\x55\x3d\xd5\xd6\xd5\xb4\x4b\x2e\x48\xf5\xad\xb1\xf7\x42\x61\x36\x18\xf4\xe9\xda\x71\x12\xb0\x2e\x47\xcb\x41\x2d\x16\xc5\x69\x2d\xcc\x62\xeb\x60\xce\x75\x5d\x5f\xb2\xc1\x55\x3f\x5d\x57\xa7\xbe\xb5\x91\xe7\xd6\x06\x8c\x32\x70\x9e\xb9\xba\xcc\x8d\x86\x97\xa1\xc2\xbb\xd9\x6e\x63\x3b\x43\x6f\x78\xd1\x48\xf6\xc4\x5b\xa5\x76\xb0\xb5\xd0\x13\x78\x03\x08\x17\x67\xa8\x19\x1b\xbd\x4a\xd2\x74\xa4\xba\x47\x9b\x9a\xa4\x2d\x90\xd7\xfa\x4e\x9a\x44\x72\x94\xd2\xf5\xc2\x1b\x1c\x69\x7e\x53\x54\x54\x99\xec\x06\xf9\x44\xb2\x58\xa2\x9c\xeb\x92\xcc\x6d\xb5\xcb\x8a\xea\x96\xf1\xe6\xa7\xf2\x43\xf8\xd7\xfa\xfe\x91\x1f\xbc\xaa\xa5\xdb\xfc\x49\xa2\xab\xd7\x72\xe9\x2d\x95\x83\x3e\x99\x29\xe7\x6a\xb8\xac\xa2\x75\x6f\x94\x2d\xa7\x4b\x6f\x52\x76\x8d\xd0\xd7\xf7\x8a\x4c\xab\xee\xf0\x64\x5e\xae\xf1\x84\xf0\xbb\x7b\x7b\xb6\xf7\xf5\xbe\x4c\x19\x7d\xb9\xe5\x93\x3d\x76\xac\x75\xbd\x6b\xb0\x31\x8c\x93\x34\xa6\xaa\x93\x29\xe5\xad\x6d\x6d\xa9\x17\xbe\x3e\x5d\x63\x7a\xbb\x57\x99\xe4\x22\x84\x3b\x27\xb4\x6d\x9d\x16\x04\xf6\xe2\x72\x7c\x1a\xcf\x7a\x1e\x1b\x15\x26\x47\x85\xa2\x77\x8c\x17\x2d\x56\xd5\x12\x5e\x4b\x4f\xba\x43\xf3\xe4\x79\x93\x9b\x71\x6b\x93\x77\xd7\xbd\xe4\x70\x6c\x1d\xfb\x8b\xd6\xe8\xb0\x8d\x78\x6e\x5a\xcd\x05\x7b\x56\x66\x7b\x69\x35\x3f\x08\x0b\xc2\x33\xa2\xbd\x3b\x9c\xb8\x47\x71\x78\xb6\x2f\x9d\x5e\xb7\x04\xe3\x5c\x9c\x6a\x9d\x68\xb2\xed\x66\x14\xb3\x2b\x4f\x7d\x62\x3e\xd6\xd7\x8a\xdf\x3f\x6e\xa4\xd9\x3c\x76\x88\xf4\x4c\xf2\x02\x9d\x2c\x3d\x65\x45\xaf\xd5\x79\x2c\x5c\x6b\xd2\x5f\xb2\x3d\x43\x9a\x84\xe9\x60\x3e\xa0\xe4\xf8\xac\xb7\xe4\xa5\xba\xac\xb9\x45\x6d\x9b\xdb\x20\x92\xc5\x2a\x5c\x33\xbc\xaa\x1f\x2d\x66\xca\x76\x76\x67\x79\xd5\x67\x7a\x1a\x3d\x49\x56\xca\x29\xb1\x46\x6c\x5a\x92\x52\x5c\xaa\x0b\xed\xe0\xad\x9d\x84\x15\xdc\xd5\xd4\x90\x89\xf5\x20\x9c\xcc\x67\x43\x4e\x0f\x8b\xf1\x76\xb1\x03\xb5\xb2\x1c\xac\x47\x44\xdc\xc9\xa8\x28\x9c\x19\x2d\xcd\x2d\xc9\xfd\x50\xa3\xf3\x7d\xd5\x8f\x47\x65\xe5\xd6\xf3\x49\x87\x3a\x4e\xaa\xd1\x70\xbf\xe3\xfd\x0e\x19\x24\xb3\x58\xe3\xc9\x75\x3f\x9c\xed\x84\xba\xbb\x6e\xa5\x7d\x61\x22\x6f\xae\x83\xd2\xf2\xbb\x6c\x38\xce\x66\xeb\xde\x7a\x42\xb8\x45\xae\xaa\x0e\x2d\x66\xbd\x7a\x73\x36\x26\xb4\x9e\x76\xb9\xd5\xb1\x63\x5c\xce\xde\xce\x9b\x48\x60\x35\x8f\xcf\x41\xbc\xe1\x65\xa3\x95\x1c\xf7\x67\xd0\xcb\x76\xeb\xae\x11\xf6\x28\xf1\xc8\xa9\x85\xee\x39\xb4\x3f\x5c\xc2\xa3\x64\xaf\x10\xe5\xbd\x5d\xc4\x17\x6f\x51\xd7\x33\x67\xda\x6f\xd1\x5e\x22\x89\x6b\x71\x5d\xf9\xf1\x34\x58\x8d\xf8\xa4\x67\xaf\xba\xf3\x25\xb7\xe8\xd7\x43\xfb\x50\x39\xad\xb8\x66\x93\x65\xbd\xcd\xc3\xe5\x16\x28\x53\x31\xf1\x8a\x39\x49\x66\x41\x67\x91\x13\xc2\x79\x41\xcb\xf1\xd6\xda\x1d\x7c\xb3\x5e\xfb\xab\xda\x62\x29\xb9\x95\x5b\x6a\x58\xad\x3a\x80\x09\xaf\x20\xd5\xa4\xf1\xc6\x5c\x24\x8a\xb4\x3a\xa6\xd9\x45\x09\x6c\x9b\x18\xec\xfa\x61\xd4\x5b\x54\x9d\x69\x5f\xa6\xc9\x2e\x11\x29\xf2\x71\xe2\x66\x7c\x57\x4e\x32\x3d\x8c\x06\x7d\x5a\x9f\xd9\x6e\xa7\x5b\x0c\x32\x31\xd6\x9d\x50\x88\xfa\xa2\x35\x32\xd8\x1d\x33\x16\x24\x69\x5e\xcf\x77\xcc\x78\x39\xa1\x4b\xf3\xa7\x7e\x95\xb0\xfa\x8b\xa5\xb2\x75\x7d\x29\x26\x1a\xdc\x8a\xa0\x1c\x34\x3e\x64\x75\x72\x9f\xe4\x17\x0a\x48\xe5\xb6\xf4\xf4\xc4\x59\xca\x3d\xaf\x75\x2a\x8a\x85\x25\x4c\xc8\x81\xc3\x0c\x89\xeb\xd6\x72\x88\x39\x60\x85\x1e\x39\x8f\xe7\xad\xee\x26\xeb\x8d\x0d\x75\x39\x4f\x72\xc2\x4a\xc2\xa2\xce\x57\xd3\xba\x3e\x55\x9c\x69\xe7\xd3\x64\x6b\xee\xf7\xc5\x61\x4a\x6b\x53\x96\x05\xcc\xf2\x5a\x2b\x6b\x3a\x65\x79\x82\xee\x27\xdb\x20\xd0\x88\x7c\xc6\x64\x2a\xbd\x32\xd2\xc5\x74\x77\x59\xc6\xc4\x72\x3b\x2a\x76\x3c\x58\x5f\x04\xb2\xeb\x78\x41\x4a\xac\x98\xb5\xb5\xed\x49\x1b\xc7\x8a\xc2\x6c\xb5\xce\x0b\x6b\x46\xb3\xd3\x75\x35\x1f\x6f\xa2\x91\xbb\x93\x3b\x2b\xf3\x28\xfa\xa6\x94\xad\x6c\xd5\xb8\xf2\x47\x82\x64\xa9\xb3\x26\x80\xf5\xb1\xdc\x82\xf9\x68\xa7\x78\x5a\x8f\x3c\xeb\xd1\x44\x24\x1d\x2b\x2a\xac\xd8\xd5\xc3\x62\x34\x5b\x93\xc4\xa6\x23\x25\x32\xe3\x99\x72\xba\x5d\x98\x95\x7f\x72\x3a\x80\xcf\xd2\xda\xdd\xf2\x07\x71\xe1\x81\x42\x29\xae\x72\x30\x64\xf2\x4d\x95\x1b\x9d\xa5\xa2\xe4\xe1\xd6\x23\xaf\xd9\x5a\x2b\x93\x32\xda\x1e\xcf\x52\x60\x5e\x63\xd7\x1f\x58\xa0\xf4\xe7\x55\xf7\x22\xf0\xfe\x90\x68\x65\xa3\xdc\xe1\x5a\x93\x5d\xe6\x26\x16\xdf\xdb\x76\xb5\x0e\x4b\x8e\x8b\x93\xae\xf5\xb5\x83\x6a\xed\x5d\x35\x70\x8e\xad\xb1\x38\x66\x5a\xbd\xa8\x37\xa7\xae\xfc\x36\xca\x87\x19\x4b\x4a\x87\xd0\xef\x97\xea\x50\xcd\x5b\xa7\x96\x52\xd4\xc5\x72\x32\x1c\xd4\x96\xef\x5a\x23\x42\x0a\x77\xf3\x85\xe7\x0f\x0a\x76\x36\x5d\x96\x7a\xd8\x6f\x99\xe7\xd9\x26\x26\x07\x67\xf9\x7a\x14\x2e\xab\x31\x55\x44\x60\xe0\x18\xad\x51\x68\x0d\x4f\x45\xbe\x27\x18\x67\x3a\xdb\xad\xe9\xed\x4c\x4e\x7a\xf6\x64\xbb\xa9\xd6\xe3\xb4\xea\xfa\xc3\xbe\x36\x61\xea\x6c\x20\x0a\x6e\x15\xd2\xdd\xa1\x39\x5d\x95\xab\xd6\x6e\x60\xed\x52\x6b\x3e\x1f\x48\xfb\x38\x57\x84\x53\x67\x96\x2c\xcf\xb3\xc9\x20\xef\x4c\x53\x46\x18\xac\x43\x75\x6a\xee\x16\xa3\x95\x68\x6d\x27\x5a\x5f\x1f\xf5\x0e\x95\x08\x92\xc1\x54\x2a\x8c\xea\xb4\x34\x86\x2b\xb7\x75\x28\x6d\xc7\xf2\xd2\xdc\x96\x17\x2b\x6d\x59\x56\x69\xaf\xeb\x0e\x05\x41\x21\x59\x6e\x50\xb5\x18\xc9\xa3\xcc\xdd\x7c\xaf\xd2\x0b\x78\x9a\x56\xd7\x36\xef\x9c\x77\xdb\xde\x84\xfb\x99\xbb\x65\xed\xff\xb5\x2a\x07\x86\xe2\xf3\x61\xfa\x44\xe6\x05\x49\x4a\x6b\xcf\x6c\x69\x3a\x67\x4d\x43\xd7\xee\x8d\x5c\xd0\x8b\x37\x9b\x64\xbd\x0d\x7a\x5d\x32\xa3\x86\xbd\x1e\x38\x5e\x3b\x07\x6f\x7c\x64\x3a\xcb\xab\x6e\x65\xe6\x4c\x37\x95\x70\x1e\x0e\xe5\x33\xe9\x66\xca\x62\xb8\xf1\x2b\x66\x95\xc8\xfc\xa6\x57\xf7\xc0\x20\x66\x8f\x36\x65\x30\xb9\x37\x3d\x4f\xbc\x20\x61\xb5\x9a\xa9\x2f\x56\x5d\x27\x64\x99\x2c\x56\x5d\xc1\x99\xa5\x27\x92\x58\x75\xb9\x96\x23\xe7\xba\x6f\xaa\x03\x91\x5f\x81\xb1\x49\x15\x73\xd9\xcc\x5a\xe9\x80\xb6\xd7\xd2\x75\x53\x47\x11\xe9\x44\x40\x5e\x68\x82\xd2\xf2\xa7\x56\xc1\x9a\x39\xbd\x0b\xf7\x7d\xae\xda\x04\x93\x23\x97\xc5\xc1\xfa\xe0\x6e\x56\x39\x79\x66\x7b\xfd\x7c\xc7\x15\xbb\x73\x97\xdb\x9c\x82\x95\xd2\x1a\x4b\x53\x62\x3a\x95\x07\xcb\xe1\x7c\xb6\x98\x27\xd9\xae\xdb\x3a\x9d\x94\x9a\x52\x54\x89\xac\xb2\xbc\x10\x98\x5c\xad\xab\x8b\x99\x1d\xb6\x9d\xca\xcf\xa4\xbe\xd3\x9a\x4b\x4b\xaa\xdb\x95\x17\x0b\x55\x1b\x69\xe1\xb5\xdb\xf2\x85\x2e\x73\xb4\xd4\x6e\x48\xd4\x1a\x3f\x9d\x8e\x7b\xfd\x24\x37\xa7\x1c\xd1\x59\x25\x23\xb2\xb2\xe7\x1d\x52\x6f\x85\xce\x78\x7e\xd9\xef\xfb\xe4\x71\xee\xda\x8b\xc3\x56\xd8\x59\x71\x18\x1f\x32\x51\x9d\x08\x99\x69\xb6\xd6\xb3\xc1\xa4\x62\xe4\xf2\x2c\x0c\x83\x63\x9c\x0f\x87\x73\x25\x64\x45\x62\x11\x2f\x2b\x0d\x74\xc7\xa7\xdd\x78\x3f\xe9\x84\xfc\x69\xb8\x71\x2b\x8d\x2b\x5d\x29\x5a\xba\x8b\xb1\x58\x9c\xe7\xce\x60\xe6\x6b\x3d\x79\x70\xae\x7a\x9b\x4c\x5d\x88\xdd\x90\x8c\x19\xbd\x8e\x25\x69\x99\x2e\x8f\x5d\x3b\x98\x3b\x8b\xd9\x01\x6c\x4c\xe6\x1c\x91\x8a\xce\xaa\xd4\x56\xec\x2b\x46\x47\x35\xaf\x73\xb7\x37\x48\xfa\x87\x93\x36\x94\x47\x9c\x68\xb7\xca\xe3\x48\xd8\xec\xce\x0b\x77\xec\x5b\x64\xca\x3b\xf9\xdc\xba\x9e\x16\x99\xb8\x3c\x4b\xd4\xc9\x95\x42\xc0\x2c\x97\xc3\xb9\x27\x5e\xbc\x8b\xda\x9f\x69\xd1\x78\x94\x11\xec\xf8\x7c\x51\xc1\x95\x9c\x90\x8b\x6e\xe6\xd7\xbe\x1b\xcb\x86\x7a\xee\x58\x83\x58\xf3\xab\x22\x0d\x3a\xd9\x60\x73\x05\x65\xe2\xc9\x4c\xa7\x6b\x97\xf1\xf9\xda\x1f\x8f\xe5\x52\x72\xf3\x69\x25\x8c\x2e\x8e\x7e\x39\xb5\x58\x37\x0e\xfa\x7d\xa3\xbf\x2f\x4d\x90\x0d\xfb\xb1\x5c\xd3\xd2\x74\xb6\x5f\x6e\x54\x63\xe0\x6e\xca\xca\x8a\x47\xb2\x06\x06\x8c\x7c\x98\x4f\xe5\x8b\xeb\x75\x68\x3d\x99\xca\x0c\x33\x70\xe2\x81\x1b\x5d\x18\x9b\x5f\xc6\xe4\x45\xf2\xc9\x2c\x1f\xa8\x23\x5a\xba\x58\x42\x47\x3c\x24\x83\x0b\x57\xcc\xe2\xe5\x45\x5c\xe5\x72\xc0\xe5\xeb\x4b\xdc\xf3\x87\xfa\xd4\xbd\x90\x2d\xc0\x0a\xda\x38\x9c\x5e\xe3\x30\xaf\x64\x7a\xee\x13\xb4\xb6\x5a\xf0\xbe\x30\x26\x15\xb9\x0f\xfa\x83\x29\x2b\x2b\xf4\x8e\x91\x8b\x89\xe1\xed\x83\xd1\xb4\x54\x4e\x53\x69\x55\x58\x33\x93\x22\x08\xef\x4a\x87\xbb\x11\x1b\xf4\x46\x46\x4f\x18\x0b\x87\x65\x6e\x91\x7a\xdf\x89\xa6\xa3\x83\xd6\xb7\xaf\x14\xb8\x72\x26\xaa\x4d\x34\x0d\x86\x33\x79\x54\xa7\xbc\xa9\xfe\x1c\x9a\x38\xc4\x56\xf5\x84\x6e\x5c\x3e\xfe\x4a\x33\x34\x4f\x3b\x5f\x9c\x38\xca\xdb\x8e\x11\xfa\x41\xf5\xf8\x30\xb0\x83\xc2\xce\x7d\xd3\xc0\x26\xf6\xc5\x7e\xf8\xfd\xf9\xf3\xef\x52\xea\x1b\xc1\xef\x99\x11\x65\xed\xcc\x4e\xfd\xdb\x3c\x24\x1c\x30\xc9\xf5\x4b\xe0\x47\x76\xdb\xb3\x7d\xd7\xcb\x1f\x01\xce\xd0\x5f\x42\x23\x75\xfd\xe8\x91\xfc\x52\xc6\xa9\xd5\x3e\xa4\xb6\x71\x7a\x44\x3f\xdb\x46\x10\x7c\x69\x97\xf6\xe1\xe4\xe7\xed\xdc\xbe\x36\x52\xda\x86\x75\xbc\x64\xf9\x23\x20\xc9\xbf\x7d\x69\x87\xd9\x67\x3d\xf7\x79\x46\xd2\xf6\x7c\xd7\x0b\xe0\x82\xcd\xad\xd8\xc7\x3c\x35\xa2\x2c\x31\x52\x3b\xca\xbf\x1b\x77\x2b\x01\xe0\x95\x0e\xfd\x05\x49\xb3\x6c\x33\x4e\x8d\xdc\x8f\xa3\xc7\x28\x8e\xec\xef\xc6\xa3\x17\x17\x76\x7a\x1f\x4a\x92\x1d\x52\x11\xdf\x0d\xbd\x44\x96\x9d\x42\xf3\xbe\x1b\x8f\x86\x99\xfb\x85\xfd\xbb\xf1\x58\xf8\x99\x9f\xdb\xd6\xdb\xa9\xdf\xb3\x3c\x8d\x23\xf7\x09\xb9\xa6\x6c\x7c\xc1\x93\xe4\xf7\xdc\x38\x04\xf6\xd3\x21\x4e\x2d\x3b\x85\xba\x06\x46\x92\xc1\x98\x34\x6f\xbe\xdc\x3a\xb2\xc4\x30\xfd\xc8\x7d\x24\xbf\x84\xc6\xb5\xb9\x4f\xdb\xd8\xfc\xf2\xb6\x91\xf4\x18\x18\x59\xde\x36\x3d\x3f\xb0\xee\x42\x0f\x71\x9e\xc7\x61\x3b\xb0\x9d\xbc\x9d\x1a\x96\x7f\xc9\x1e\xe9\xe4\xfa\xe5\x6d\x6f\x8a\x7c\xf5\xd2\xfd\x3d\x4f\x1f\x1d\x3f\xbd\xcb\xc2\xf2\x67\x71\x79\x9c\x3c\x92\xb0\x3b\xca\xbd\x76\xec\xb4\xf3\x2a\xb1\xff\x6e\x17\x76\xf4\x8f\xd7\xdb\xcb\xcd\x76\x87\x77\x04\xc7\xf8\xfe\x76\x36\x48\xae\x58\x16\x07\xbe\x85\xfd\x6a\x89\xd6\xc1\xa6\xbe\x24\x86\x65\x41\xf3\x70\x8e\xb5\xc3\x2f\x85\x9d\x42\x58\x05\x6d\x23\xf0\xdd\xe8\x31\x8f\x93\xef\xbf\x26\x86\x0b\x21\x64\x58\x76\xfa\x84\x9a\xdb\x7e\x6e\x87\xd9\xa3\x69\x47\xb9\x9d\xbe\xc2\xf4\xe3\xaf\xe4\x81\x36\x58\xfa\xad\x7d\x8f\xcc\xcb\x9a\x9c\x68\x32\xa6\xf5\xe5\xae\xa1\xe3\x7c\xb1\xfc\x2c\x09\x8c\xea\xd1\x09\xec\xeb\x6b\xec\xe2\x80\xb2\xc3\x2f\xaf\x23\xc6\x92\xe4\x17\x08\x38\xdf\xa9\xda\x30\x6f\xec\x28\x7f\x84\xb1\xb1\xdb\x07\x3b\x2f\x6d\x3b\x7a\x36\x85\xc4\x80\x1d\xbe\xd1\x1b\x7b\xc6\x5d\xa3\xc1\x0f\x9d\x37\xfc\xdc\xc7\x88\x86\xc5\x58\x87\x1f\xc7\xbc\xc1\xa4\xe3\x38\x6f\xfa\xdb\x41\xec\xc6\x4f\xb7\x3c\xa3\x70\x0a\xfa\xf2\x96\x69\x38\x6f\x87\xd8\xcb\x0f\xf2\x86\x1b\x1e\x07\xec\x0f\x5a\xb6\x43\x3b\xba\x7c\xe4\xe2\x37\x4e\xba\x8b\x85\xf1\xc2\xc8\xf7\x02\x30\xcb\x2f\x9e\xee\x59\x8e\xe1\xdc\x47\x8b\xc0\x31\xaf\xe1\xfa\x3c\x1c\xfe\xf7\xc9\x94\xac\x70\x9f\x1c\x3f\x08\xee\x3e\xfc\xf2\xcc\x2a\xc2\xb3\xb1\x08\x63\x38\xa0\x3e\xb4\x0c\x4a\xb8\x79\xb1\x91\x03\x9d\x88\xc3\x1e\x64\x6d\x3b\x32\xd2\x34\x2e\x9f\xee\xc6\x22\x2a\xf8\xf5\x16\xe9\x1b\x86\x3f\xc0\xef\x0d\x6b\xb7\xf4\x81\x94\x77\x33\x06\x61\xe0\x36\xfd\x0e\xdf\xf7\x59\x62\x5b\x0e\xe9\x30\x3f\x20\xf6\xd3\x55\xf2\x38\xf9\x2c\x99\x61\xd7\x8f\x99\xfc\x92\x5c\x30\xf2\x50\x21\x1c\xa6\x6c\xdb\x37\xe3\xe8\xe9\x46\x1f\x0d\x0c\xf0\x28\x46\xbf\xf1\x41\x4c\xfc\x54\x7a\x7e\x6e\x23\xe2\xb1\x1f\xa3\xb8\x4c\x8d\xe4\x76\x90\xf4\x8c\xcc\xbb\x43\x90\x77\x04\x46\x04\xdf\xff\x2b\xb4\x2d\xdf\xc0\xe2\x28\xa8\xb0\xcc\x4c\x6d\x3b\xc2\x8c\xc8\xc2\xfe\xfe\x42\x56\x2c\x49\x26\xd7\x7f\x3c\x7d\xee\x69\x3f\x42\x34\xfa\x6a\x40\xe9\x5b\xf6\xdb\x40\xdc\xd7\x49\x52\x3f\xca\x9f\xde\x70\xc2\x87\x01\xbb\x75\xfe\xfe\xa2\xf7\xef\xaf\x37\x39\x92\x24\xdf\x07\xe7\xb3\x18\xbc\x1e\xfc\x01\x10\x60\xb7\xf1\x11\xf7\x93\xff\x6c\xcf\xf8\xdf\x5e\x6a\x3b\xff\xe7\xd1\x70\x72\x94\xd5\x0d\x9f\x3c\x60\x7f\x7f\xc0\x8c\x3c\x4f\xff\x0e\x7b\xff\x81\x3d\xfc\xe3\xe1\x7b\x9e\x3e\x21\x6b\x9b\x4d\xd2\x8f\x32\xdf\xb2\x1f\x8d\x22\xf6\xad\x7f\x91\x89\x5f\xef\x7f\x9f\xb2\x31\x34\xe2\xfb\x7f\xc1\x0d\xb6\xf0\xed\x32\x89\xd3\xfc\x06\x10\xcb\x2e\x7c\xf3\xf6\xfb\xc1\xef\xbf\x7c\x25\xd0\x73\xf6\x7f\xfc\xf2\xcb\xd7\xdc\xcf\x03\xfb\x8f\xa7\x27\x0c\x9f\x19\xb9\x87\x7d\xff\xfe\x95\x68\x9a\x7e\xf9\x4a\x40\x8f\xfe\xf1\xcb\x57\xe8\xf1\x3f\x7e\xc1\xb0\xaf\x96\x5f\x60\xbe\xf5\xed\xe1\x55\xd8\x1e\x60\xc7\xc7\x5d\x88\xcc\x1e\x30\x33\x30\xb2\xec\xdb\x03\x0a\x20\x6a\xf9\xe3\x7f\x45\x87\x2c\xf9\xf2\x95\xb0\xfc\xe2\x9f\xcc\x86\x30\xba\x49\xbf\x8d\xb8\x49\x7a\x8b\xaf\x87\x3f\xbe\x1a\x18\x74\xf3\xb7\x07\x2f\xcf\x93\xec\x91\x20\xe0\x52\xb8\x1f\x3f\x60\xb9\x91\xba\x76\xfe\xed\xe1\xbf\x0f\x81\x11\x9d\x1e\xb0\xd4\x0e\xbe\x3d\x44\x71\x9c\xd8\x91\x9d\x62\x51\x9c\xda\x8e\x9d\xa6\xd0\x08\xe9\x10\x5f\x72\x6c\x38\xeb\x2d\xbf\x12\xc6\x1f\xaf\x54\xfb\xff\x5b\xfa\x57\x3f\xca\x72\x23\x08\xfe\x1d\x15\x86\xcd\x94\x7f\x47\x89\x26\x01\x7f\xa2\x07\x7e\xd2\xba\xff\x81\xf9\x1f\x6a\x70\x7f\x8f\x61\xef\x56\x74\xfd\xdc\xbb\x1c\x70\x33\x0e\xd1\xe2\x84\xe5\xa7\x6d\x3f\xb2\xec\x6b\xdb\xcb\xc3\x80\xf0\xb3\xec\x62\x67\xc4\xbf\xa3\xc8\xf3\x5a\x18\xf6\x35\x2b\xdc\xdb\xd7\x59\x1e\x3e\xff\x3a\xcb\xc3\xf3\xd7\x59\x1e\xe0\xbe\x07\x04\x9c\xc1\x28\xf0\xf0\xc7\x57\xd3\x4f\xcd\xc0\xc6\xcc\xeb\xb7\x07\x1e\x67\x1f\x30\xb3\xfa\xf6\xc0\xe0\xc2\x03\x96\x7e\x7b\x00\x0f\xc4\x9b\x01\x00\xe0\xe0\x83\x11\xb7\x47\x03\x1e\x34\xf4\x5c\xbe\x80\x33\x66\x9b\x44\xcf\xc7\xb1\xe8\x71\x1e\x0a\x3d\xfb\xc7\xa2\x67\x75\xd1\x83\xaf\x64\x9b\xc6\xc0\xed\x31\x4f\x76\x00\x27\xd5\x6f\xc4\x08\x38\x8b\x89\x38\x3f\x60\x91\x1c\x8c\xc4\x85\x36\x89\x1e\x4f\xe2\xd1\x2b\x5c\x84\xc4\x28\xf4\x98\x95\x80\x31\xe8\x1f\x85\xb1\x38\xb5\x11\x7f\x94\x04\x68\x9c\x41\xa2\x44\x5c\x2c\x78\x5c\x34\x29\x9c\x69\x93\x38\x03\x67\x20\x7d\x18\xf4\x48\x28\xd5\x05\x0c\x0e\x30\x70\x7b\x88\x51\xc4\x00\x5c\xf7\x3e\xb9\xfe\xd1\x0b\x2c\xce\x37\x5e\x00\x14\x2e\x7e\xec\x28\xf6\xee\x28\xc0\xe2\xcc\x67\x43\xe8\xdb\x10\xf2\x93\x21\xd4\x9f\xae\x43\x3f\xcb\xf8\x6c\x19\xfa\x59\x91\x37\xab\x40\x48\xbc\x02\x2c\x61\x3c\x23\xf9\x15\xe1\xdd\xdf\xbe\xbc\xb9\x53\xe0\x6d\x0f\x79\xcb\x7c\xaf\x3a\xde\xf2\x6e\x83\x52\x74\x5d\xf2\xc7\x10\xc2\x1e\x8b\x1d\xec\x0d\x99\xdf\x3a\x9f\x47\x3f\x3d\x61\xbe\x83\xe1\x03\x23\x83\xfd\x2f\x42\x5e\x25\xfa\xf3\x5e\xfb\x26\x19\xa0\xd4\x77\xb3\x88\x37\xd9\xf9\xf4\x84\xd9\x91\xf5\x32\xe0\x6d\x22\xa3\xab\x9b\x57\x6a\xe7\xe9\x9b\x5c\xcb\xad\xfb\xfa\xcf\x87\x9b\x37\xeb\x7f\xa0\xe3\x2d\x99\xdf\x6f\x28\xf7\xe5\x73\xeb\x87\x25\x7e\x10\x78\x67\x93\xa7\x27\xbc\x63\x98\x27\xd5\x8f\x4e\xd8\xff\xc5\x2e\x69\xa0\x64\xa6\x91\xd8\xdf\xbf\x3f\xfc\x81\xe3\xaf\x42\xf8\x99\xd4\xb7\x6d\x5f\x89\xd7\xa6\x3d\x3d\x61\xa9\x11\xb9\x36\x86\xab\x7e\x96\xfb\x91\xfb\xc6\x81\xff\x91\x13\x9e\x9e\xe0\x80\x5e\x1a\x87\xca\x35\xc7\xf0\x89\x11\x22\x95\x7f\x82\x3b\x6e\x00\x7a\xe5\x0b\x0c\x4a\x86\x1d\x70\x15\x84\xac\x3f\xf3\xca\x5d\xcb\xd7\x67\xd2\x46\xc4\xd2\xaf\x1b\x11\x9f\x79\xed\x3d\x90\x9e\xc1\x73\x33\xeb\x2b\xd1\x9c\x4a\xbe\x12\x90\xe7\xff\xf8\xe5\xff\x05\x00\x00\xff\xff\xae\x6a\x73\xf3\xc0\x60\x01\x00") func dirIndexHtmlDirIndexHtmlBytes() ([]byte, error) { return bindataRead( @@ -240,12 +240,12 @@ func dirIndexHtmlDirIndexHtml() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "dir-index-html/dir-index.html", size: 77731, mode: os.FileMode(420), modTime: time.Unix(1587507325, 0)} + info := bindataFileInfo{name: "dir-index-html/dir-index.html", size: 90304, mode: os.FileMode(420), modTime: time.Unix(1588699867, 0)} a := &asset{bytes: bytes, info: info} return a, nil } -var _dirIndexHtmlKnowniconsTxt = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x1c\xd0\x5d\x8e\xc3\x20\x0c\x04\xe0\xf7\x39\xcc\xbc\xec\x5e\xc8\xe5\x2f\x74\x61\xe3\xc6\x56\x4a\x7a\xfa\xca\x79\xf9\x90\x41\x68\x34\xa6\x48\x02\xa5\xd7\x1a\x82\x72\x76\xf0\x31\x15\x4c\x60\xd2\x38\xcd\xc0\x2c\x0e\xe6\xd9\xc0\xbc\xa7\xc0\x17\x98\xdf\x31\xaf\x0a\x16\x35\xb0\xac\x02\xd6\x71\x82\xad\x57\x70\x03\xb7\xf8\xbf\xf9\x1c\x60\x4f\x06\x76\xdb\xc1\xa7\x9c\x02\x3e\xb5\x05\x25\x34\xf0\xaf\x5c\xe0\x28\x11\x35\x7b\x06\xa7\xfe\x04\xbf\x41\x03\xf7\x5c\x03\x0b\x1c\xdc\x5d\x83\x18\xdd\x41\x8d\x57\xdd\x14\xd4\xff\x06\xaa\xc6\x9d\x65\x50\x2f\xf0\xe5\xe0\x21\x07\x78\x3c\xc0\xc3\x2b\x68\x12\x31\x76\xf7\xb2\xd7\x00\xbd\x49\xf0\x01\xfd\xde\x83\x2f\x07\xdf\x72\x82\x6b\xd8\xcd\x02\x57\xb4\xb8\x82\x4f\x57\x7c\x03\x00\x00\xff\xff\x93\x43\x2e\x24\x37\x01\x00\x00") +var _dirIndexHtmlKnowniconsTxt = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x1c\xd0\x5d\x8e\xc3\x20\x0c\x04\xe0\xf7\x39\xcc\xbc\xec\x5e\xc8\x0d\x3f\xa1\x0d\x8b\x1b\x5b\x94\xf4\xf4\x2b\xe7\xe5\x43\x06\xa1\xd1\x98\x22\x1b\x28\xad\x94\x10\x94\xd9\xc0\x47\x57\x70\x03\x37\x8d\xd3\x0c\x4c\xe2\x60\xea\x15\x4c\x63\x0b\x7c\x81\xe9\x13\xf3\x2a\x60\x56\x03\xf3\xca\x60\x39\x26\x58\x5b\x01\x77\x70\x8f\xff\xbb\xf7\x03\x6c\x9b\x81\xcd\x06\xf8\x94\x29\xe0\x53\x6b\x90\x43\x03\x5f\xf9\x02\x8f\x1c\x51\xbd\x25\xb0\xbf\x26\xd8\x47\xa0\x3f\xc1\x6f\x50\xc1\x91\x4a\x60\x81\x83\xc3\x35\x88\xd1\x1d\xd4\x78\xd5\x5d\x41\xfd\xab\xa0\x6a\xdc\x59\x02\xf5\x02\xdf\x0e\x9e\x72\x82\xe7\x03\x3c\xbd\x80\x26\x11\x68\x77\x43\x7b\x1f\xa0\x57\x09\xbe\xa0\xdf\x1b\xf1\xe5\xe0\x47\x26\xf8\xe9\x13\x5c\x87\xdd\x2c\x70\x45\xa9\x2b\xf8\x36\xc5\x7f\x00\x00\x00\xff\xff\x1a\xae\x71\x74\x46\x01\x00\x00") func dirIndexHtmlKnowniconsTxtBytes() ([]byte, error) { return bindataRead( @@ -260,7 +260,7 @@ func dirIndexHtmlKnowniconsTxt() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "dir-index-html/knownIcons.txt", size: 311, mode: os.FileMode(420), modTime: time.Unix(1587092650, 0)} + info := bindataFileInfo{name: "dir-index-html/knownIcons.txt", size: 326, mode: os.FileMode(420), modTime: time.Unix(1588699867, 0)} a := &asset{bytes: bytes, info: info} return a, nil } diff --git a/assets/bindata_version_hash.go b/assets/bindata_version_hash.go new file mode 100644 index 00000000000..de2ddfb5d45 --- /dev/null +++ b/assets/bindata_version_hash.go @@ -0,0 +1,6 @@ +// File generated together with 'bindata.go' when running `go generate .` DO NOT EDIT. (@generated) +package assets + +const ( + BindataVersionHash = "c1aa0601ac3eac2c50b296cf618a6747eeba8579" +) diff --git a/assets/dir-index-html b/assets/dir-index-html index 545a1fd882f..e39165569c4 160000 --- a/assets/dir-index-html +++ b/assets/dir-index-html @@ -1 +1 @@ -Subproject commit 545a1fd882f34f8cd0ae84ece19d458d62471549 +Subproject commit e39165569c4b2f9d382f925b77c1126c5170946f diff --git a/bin/mkreleaselog b/bin/mkreleaselog index 12f2952490f..c30ee7051df 100755 --- a/bin/mkreleaselog +++ b/bin/mkreleaselog @@ -6,8 +6,30 @@ export GOPATH="$(go env GOPATH)" alias jq="jq --unbuffered" -[[ -n "${REPO_FILTER+x}" ]] || REPO_FILTER="github.com/(ipfs|libp2p|ipld)" -[[ -n "${IGNORED_FILES+x}" ]] || IGNORED_FILES='^\(\.gx\|package.json\|\.travis.yml\|go.mod\|go.sum\)$' +AUTHORS=( + # orgs + ipfs + ipld + libp2p + multiformats + filecoin-project + ipfs-shipyard + + # Authors of personal repos used by go-ipfs that should be mentioned in the + # release notes. + whyrusleeping + Kubuxu + jbenet + Stebalien + marten-seemann + hsanjuan + lucas-clemente + warpfork +) + +[[ -n "${REPO_FILTER+x}" ]] || REPO_FILTER="github.com/(${$(printf "|%s" "${AUTHORS[@]}"):1})" + +[[ -n "${IGNORED_FILES+x}" ]] || IGNORED_FILES='^\(\.gx\|package\.json\|\.travis\.yml\|go.mod\|go\.sum|\.github|\.circleci\)$' NL=$'\n' @@ -66,27 +88,42 @@ resolve_commits() { jq '. + {Ref: (.Version|capture("^((?.*)\\+incompatible|v.*-(0\\.)?[0-9]{14}-(?[a-f0-9]{12})|(?v.*))$") | .ref1 // .ref2 // .ref3)}' } +pr_link() { + local repo="$1" + local prnum="$2" + local ghname="${repo##github.com/}" + printf -- "[%s#%s](https://%s/pull/%s)" "$ghname" "$prnum" "$repo" "$prnum" +} + # Generate a release log for a range of commits in a single repo. release_log() { + setopt local_options BASH_REMATCH + local repo="$1" local start="$2" local end="${3:-HEAD}" - local ghname="${repo##github.com/}" local dir="$GOPATH/src/$repo" - local commit prnum + local commit pr git -C "$dir" log \ --format='tformat:%H %s' \ - --merges \ + --first-parent \ "$start..$end" | - sed -n -e 's/\([a-f0-9]\+\) .*#\([0-9]\+\).*/\1 \2/p' | - while read commit prnum; do + while read commit subject; do # Skip gx-only PRs. git -C "$dir" diff-tree --no-commit-id --name-only "$commit^" "$commit" | grep -v "${IGNORED_FILES}" >/dev/null || continue - local desc="$(git -C "$dir" show --summary --format='tformat:%b' "$commit" | head -1)" - printf -- "- %s ([%s#%s](https://%s/pull/%s))\n" "$desc" "$ghname" "$prnum" "$repo" "$prnum" + if [[ "$subject" =~ '^Merge pull request #([0-9]+) from' ]]; then + local prnum="${BASH_REMATCH[2]}" + local desc="$(git -C "$dir" show --summary --format='tformat:%b' "$commit" | head -1)" + printf -- "- %s (%s)\n" "$desc" "$(pr_link "$repo" "$prnum")" + elif [[ "$subject" =~ '\(#([0-9]+)\)$' ]]; then + local prnum="${BASH_REMATCH[2]}" + printf -- "- %s (%s)\n" "$subject" "$(pr_link "$repo" "$prnum")" + else + printf -- "- %s\n" "$subject" + fi done } @@ -124,7 +161,13 @@ recursive_release_log() { local start="${1:-$(git tag -l | sort -V | grep -v -- '-rc' | grep 'v'| tail -n1)}" local end="${2:-$(git rev-parse HEAD)}" local repo_root="$(git rev-parse --show-toplevel)" - local package="$(go list)" + local package="$(cd "$repo_root" && go list)" + + if ! [[ "${GOPATH}/${package}" != "${repo_root}" ]]; then + echo "This script requires the target package and all dependencies to live in a GOPATH." + return 1 + fi + ( local result=0 local workspace="$(mktemp -d)" diff --git a/cmd/ipfs/daemon.go b/cmd/ipfs/daemon.go index e5a9b922cb6..11769dbd031 100644 --- a/cmd/ipfs/daemon.go +++ b/cmd/ipfs/daemon.go @@ -174,7 +174,7 @@ Headers. cmds.BoolOption(migrateKwd, "If true, assume yes at the migrate prompt. If false, assume no."), cmds.BoolOption(enablePubSubKwd, "Instantiate the ipfs daemon with the experimental pubsub feature enabled."), cmds.BoolOption(enableIPNSPubSubKwd, "Enable IPNS record distribution through pubsub; enables pubsub."), - cmds.BoolOption(enableMultiplexKwd, "Add the experimental 'go-multiplex' stream muxer to libp2p on construction.").WithDefault(true), + cmds.BoolOption(enableMultiplexKwd, "DEPRECATED"), // TODO: add way to override addresses. tricky part: updating the config if also --init. // cmds.StringOption(apiAddrKwd, "Address for the daemon rpc API (overrides config)"), @@ -296,7 +296,10 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment offline, _ := req.Options[offlineKwd].(bool) ipnsps, _ := req.Options[enableIPNSPubSubKwd].(bool) pubsub, _ := req.Options[enablePubSubKwd].(bool) - mplex, _ := req.Options[enableMultiplexKwd].(bool) + if _, hasMplex := req.Options[enableMultiplexKwd]; hasMplex { + log.Errorf("The mplex multiplexer has been enabled by default and the experimental %s flag has been removed.") + log.Errorf("To disable this multiplexer, please configure `Swarm.Transports.Multiplexers'.") + } // Start assembling node config ncfg := &core.BuildCfg{ @@ -307,7 +310,6 @@ func daemonFunc(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment ExtraOpts: map[string]bool{ "pubsub": pubsub, "ipnsps": ipnsps, - "mplex": mplex, }, //TODO(Kubuxu): refactor Online vs Offline by adding Permanent vs Ephemeral } diff --git a/core/commands/commands_test.go b/core/commands/commands_test.go index 7c8065bb32d..940b9e0f43f 100644 --- a/core/commands/commands_test.go +++ b/core/commands/commands_test.go @@ -195,6 +195,7 @@ func TestCommands(t *testing.T) { "/stats", "/stats/bitswap", "/stats/bw", + "/stats/dht", "/stats/repo", "/swarm", "/swarm/addrs", diff --git a/core/commands/pin.go b/core/commands/pin.go index d27b0212110..165dad26d23 100644 --- a/core/commands/pin.go +++ b/core/commands/pin.go @@ -13,8 +13,6 @@ import ( cidenc "github.com/ipfs/go-cidutil/cidenc" cmds "github.com/ipfs/go-ipfs-cmds" offline "github.com/ipfs/go-ipfs-exchange-offline" - pin "github.com/ipfs/go-ipfs-pinner" - ipld "github.com/ipfs/go-ipld-format" dag "github.com/ipfs/go-merkledag" verifcid "github.com/ipfs/go-verifcid" coreiface "github.com/ipfs/interface-go-ipfs-core" @@ -24,7 +22,6 @@ import ( core "github.com/ipfs/go-ipfs/core" cmdenv "github.com/ipfs/go-ipfs/core/commands/cmdenv" e "github.com/ipfs/go-ipfs/core/commands/e" - coreapi "github.com/ipfs/go-ipfs/core/coreapi" ) var PinCmd = &cmds.Command{ @@ -320,11 +317,6 @@ Example: cmds.BoolOption(pinStreamOptionName, "s", "Enable streaming of pins as they are discovered."), }, Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error { - n, err := cmdenv.GetNode(env) - if err != nil { - return err - } - api, err := cmdenv.GetApi(env, req) if err != nil { return err @@ -352,9 +344,9 @@ Example: } if len(req.Arguments) > 0 { - err = pinLsKeys(req, typeStr, n, api, emit) + err = pinLsKeys(req, typeStr, api, emit) } else { - err = pinLsAll(req, typeStr, n.Pinning, n.DAG, emit) + err = pinLsAll(req, typeStr, api, emit) } if err != nil { return err @@ -431,24 +423,30 @@ type PinLsObject struct { Type string `json:",omitempty"` } -func pinLsKeys(req *cmds.Request, typeStr string, n *core.IpfsNode, api coreiface.CoreAPI, emit func(value interface{}) error) error { - mode, ok := pin.StringToMode(typeStr) - if !ok { - return fmt.Errorf("invalid pin mode '%s'", typeStr) - } - +func pinLsKeys(req *cmds.Request, typeStr string, api coreiface.CoreAPI, emit func(value interface{}) error) error { enc, err := cmdenv.GetCidEncoder(req) if err != nil { return err } + switch typeStr { + case "all", "direct", "indirect", "recursive": + default: + return fmt.Errorf("invalid type '%s', must be one of {direct, indirect, recursive, all}", typeStr) + } + + opt, err := options.Pin.IsPinned.Type(typeStr) + if err != nil { + panic("unhandled pin type") + } + for _, p := range req.Arguments { - c, err := api.ResolvePath(req.Context, path.New(p)) + rp, err := api.ResolvePath(req.Context, path.New(p)) if err != nil { return err } - pinType, pinned, err := n.Pinning.IsPinnedWithType(req.Context, c.Cid(), mode) + pinType, pinned, err := api.Pin().IsPinned(req.Context, rp, opt) if err != nil { return err } @@ -466,7 +464,7 @@ func pinLsKeys(req *cmds.Request, typeStr string, n *core.IpfsNode, api coreifac err = emit(&PinLsOutputWrapper{ PinLsObject: PinLsObject{ Type: pinType, - Cid: enc.Encode(c.Cid()), + Cid: enc.Encode(rp.Cid()), }, }) if err != nil { @@ -477,38 +475,42 @@ func pinLsKeys(req *cmds.Request, typeStr string, n *core.IpfsNode, api coreifac return nil } -func pinLsAll(req *cmds.Request, typeStr string, pinning pin.Pinner, dag ipld.DAGService, emit func(value interface{}) error) error { - pinCh, errCh := coreapi.PinLsAll(req.Context, typeStr, pinning, dag) - +func pinLsAll(req *cmds.Request, typeStr string, api coreiface.CoreAPI, emit func(value interface{}) error) error { enc, err := cmdenv.GetCidEncoder(req) if err != nil { return err } - ctx := req.Context -loop: - for { - select { - case p, ok := <-pinCh: - if !ok { - break loop - } - if err := emit(&PinLsOutputWrapper{ - PinLsObject: PinLsObject{ - Type: p.Type(), - Cid: enc.Encode(p.Path().Cid()), - }, - }); err != nil { - return err - } + switch typeStr { + case "all", "direct", "indirect", "recursive": + default: + err = fmt.Errorf("invalid type '%s', must be one of {direct, indirect, recursive, all}", typeStr) + return err + } + + opt, err := options.Pin.Ls.Type(typeStr) + if err != nil { + panic("unhandled pin type") + } + + pins, err := api.Pin().Ls(req.Context, opt) + if err != nil { + return err + } - case <-ctx.Done(): - return ctx.Err() + for p := range pins { + err = emit(&PinLsOutputWrapper{ + PinLsObject: PinLsObject{ + Type: p.Type(), + Cid: enc.Encode(p.Path().Cid()), + }, + }) + if err != nil { + return err } } - err = <-errCh - return err + return nil } const ( diff --git a/core/commands/refs.go b/core/commands/refs.go index 4a7285cc95c..828853e38f0 100644 --- a/core/commands/refs.go +++ b/core/commands/refs.go @@ -13,6 +13,7 @@ import ( cidenc "github.com/ipfs/go-cidutil/cidenc" cmds "github.com/ipfs/go-ipfs-cmds" ipld "github.com/ipfs/go-ipld-format" + merkledag "github.com/ipfs/go-merkledag" iface "github.com/ipfs/interface-go-ipfs-core" path "github.com/ipfs/interface-go-ipfs-core/path" ) @@ -102,6 +103,7 @@ NOTE: List all references recursively by using the flag '-r'. format = " -> " } + // TODO: use session for resolving as well. objs, err := objectsForPaths(ctx, api, req.Arguments) if err != nil { return err @@ -109,7 +111,7 @@ NOTE: List all references recursively by using the flag '-r'. rw := RefWriter{ res: res, - DAG: api.Dag(), + DAG: merkledag.NewSession(ctx, api.Dag()), Ctx: ctx, Unique: unique, PrintFmt: format, @@ -164,16 +166,16 @@ Displays the hashes of all local objects. Type: RefWrapper{}, } -func objectsForPaths(ctx context.Context, n iface.CoreAPI, paths []string) ([]ipld.Node, error) { - objects := make([]ipld.Node, len(paths)) +func objectsForPaths(ctx context.Context, n iface.CoreAPI, paths []string) ([]cid.Cid, error) { + roots := make([]cid.Cid, len(paths)) for i, sp := range paths { - o, err := n.ResolveNode(ctx, path.New(sp)) + o, err := n.ResolvePath(ctx, path.New(sp)) if err != nil { return nil, err } - objects[i] = o + roots[i] = o.Cid() } - return objects, nil + return roots, nil } type RefWrapper struct { @@ -183,7 +185,7 @@ type RefWrapper struct { type RefWriter struct { res cmds.ResponseEmitter - DAG ipld.DAGService + DAG ipld.NodeGetter Ctx context.Context Unique bool @@ -194,7 +196,11 @@ type RefWriter struct { } // WriteRefs writes refs of the given object to the underlying writer. -func (rw *RefWriter) WriteRefs(n ipld.Node, enc cidenc.Encoder) (int, error) { +func (rw *RefWriter) WriteRefs(c cid.Cid, enc cidenc.Encoder) (int, error) { + n, err := rw.DAG.Get(rw.Ctx, c) + if err != nil { + return 0, err + } return rw.writeRefsRecursive(n, 0, enc) } diff --git a/core/commands/root.go b/core/commands/root.go index 752cfd4e3f3..5d00770f006 100644 --- a/core/commands/root.go +++ b/core/commands/root.go @@ -46,7 +46,7 @@ DATA STRUCTURE COMMANDS ADVANCED COMMANDS daemon Start a long-running daemon process - mount Mount an IPFS read-only mountpoint + mount Mount an IPFS read-only mount point resolve Resolve any type of name name Publish and resolve IPNS names key Create and list IPNS name keypairs diff --git a/core/commands/stat.go b/core/commands/stat.go index 7da0b7ddd56..8b83ee4d58d 100644 --- a/core/commands/stat.go +++ b/core/commands/stat.go @@ -29,6 +29,7 @@ for your IPFS node.`, "bw": statBwCmd, "repo": repoStatCmd, "bitswap": bitswapStatCmd, + "dht": statDhtCmd, }, } diff --git a/core/commands/stat_dht.go b/core/commands/stat_dht.go new file mode 100644 index 00000000000..0a4517c8a0c --- /dev/null +++ b/core/commands/stat_dht.go @@ -0,0 +1,194 @@ +package commands + +import ( + "fmt" + "io" + "text/tabwriter" + "time" + + cmdenv "github.com/ipfs/go-ipfs/core/commands/cmdenv" + + cmds "github.com/ipfs/go-ipfs-cmds" + "github.com/libp2p/go-libp2p-core/network" + pstore "github.com/libp2p/go-libp2p-core/peerstore" + dht "github.com/libp2p/go-libp2p-kad-dht" + kbucket "github.com/libp2p/go-libp2p-kbucket" +) + +type dhtPeerInfo struct { + ID string + Connected bool + AgentVersion string + LastUsefulAt string + LastQueriedAt string +} + +type dhtStat struct { + Name string + Buckets []dhtBucket +} + +type dhtBucket struct { + LastRefresh string + Peers []dhtPeerInfo +} + +var statDhtCmd = &cmds.Command{ + Helptext: cmds.HelpText{ + Tagline: "Returns statistics about the node's DHT(s)", + ShortDescription: ` +Returns statistics about the DHT(s) the node is participating in. + +This interface is not stable and may change from release to release. +`, + }, + Arguments: []cmds.Argument{ + cmds.StringArg("dht", false, true, "The DHT whose table should be listed (wan or lan). Defaults to both."), + }, + Options: []cmds.Option{}, + Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error { + nd, err := cmdenv.GetNode(env) + if err != nil { + return err + } + + if !nd.IsOnline { + return ErrNotOnline + } + + if nd.DHT == nil { + return ErrNotDHT + } + + id := kbucket.ConvertPeerID(nd.Identity) + + dhts := req.Arguments + if len(dhts) == 0 { + dhts = []string{"wan", "lan"} + } + + for _, name := range dhts { + var dht *dht.IpfsDHT + switch name { + case "wan": + dht = nd.DHT.WAN + case "lan": + dht = nd.DHT.LAN + default: + return cmds.Errorf(cmds.ErrClient, "unknown dht type: %s", name) + } + + rt := dht.RoutingTable() + lastRefresh := rt.GetTrackedCplsForRefresh() + infos := rt.GetPeerInfos() + buckets := make([]dhtBucket, 0, len(lastRefresh)) + for _, pi := range infos { + cpl := kbucket.CommonPrefixLen(id, kbucket.ConvertPeerID(pi.Id)) + if len(buckets) <= cpl { + buckets = append(buckets, make([]dhtBucket, 1+cpl-len(buckets))...) + } + + info := dhtPeerInfo{ID: pi.Id.String()} + + if ver, err := nd.Peerstore.Get(pi.Id, "AgentVersion"); err == nil { + info.AgentVersion, _ = ver.(string) + } else if err == pstore.ErrNotFound { + // ignore + } else { + // this is a bug, usually. + log.Errorw( + "failed to get agent version from peerstore", + "error", err, + ) + } + if !pi.LastUsefulAt.IsZero() { + info.LastUsefulAt = pi.LastUsefulAt.Format(time.RFC3339) + } + + if !pi.LastSuccessfulOutboundQueryAt.IsZero() { + info.LastQueriedAt = pi.LastSuccessfulOutboundQueryAt.Format(time.RFC3339) + } + + info.Connected = nd.PeerHost.Network().Connectedness(pi.Id) == network.Connected + + buckets[cpl].Peers = append(buckets[cpl].Peers, info) + } + for i := 0; i < len(buckets) && i < len(lastRefresh); i++ { + refreshTime := lastRefresh[i] + if !refreshTime.IsZero() { + buckets[i].LastRefresh = refreshTime.Format(time.RFC3339) + } + } + if err := res.Emit(dhtStat{ + Name: name, + Buckets: buckets, + }); err != nil { + return err + } + } + + return nil + }, + Encoders: cmds.EncoderMap{ + cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out dhtStat) error { + tw := tabwriter.NewWriter(w, 4, 4, 2, ' ', 0) + defer tw.Flush() + + // Formats a time into XX ago and remove any decimal + // parts. That is, change "2m3.00010101s" to "2m3s ago". + now := time.Now() + since := func(t time.Time) string { + return now.Sub(t).Round(time.Second).String() + " ago" + } + + count := 0 + for _, bucket := range out.Buckets { + count += len(bucket.Peers) + } + + fmt.Fprintf(tw, "DHT %s (%d peers):\t\t\t\n", out.Name, count) + + for i, bucket := range out.Buckets { + lastRefresh := "never" + if bucket.LastRefresh != "" { + t, err := time.Parse(time.RFC3339, bucket.LastRefresh) + if err != nil { + return err + } + lastRefresh = since(t) + } + fmt.Fprintf(tw, " Bucket %2d (%d peers) - refreshed %s:\t\t\t\n", i, len(bucket.Peers), lastRefresh) + fmt.Fprintln(tw, " Peer\tlast useful\tlast queried\tAgent Version") + + for _, p := range bucket.Peers { + lastUseful := "never" + if p.LastUsefulAt != "" { + t, err := time.Parse(time.RFC3339, p.LastUsefulAt) + if err != nil { + return err + } + lastUseful = since(t) + } + + lastQueried := "never" + if p.LastUsefulAt != "" { + t, err := time.Parse(time.RFC3339, p.LastQueriedAt) + if err != nil { + return err + } + lastQueried = since(t) + } + + state := " " + if p.Connected { + state = "@" + } + fmt.Fprintf(tw, " %s %s\t%s\t%s\t%s\n", state, p.ID, lastUseful, lastQueried, p.AgentVersion) + } + fmt.Fprintln(tw, "\t\t\t") + } + return nil + }), + }, + Type: dhtStat{}, +} diff --git a/core/commands/swarm.go b/core/commands/swarm.go index b1d68e21a16..ad0526a25ec 100644 --- a/core/commands/swarm.go +++ b/core/commands/swarm.go @@ -19,8 +19,6 @@ import ( config "github.com/ipfs/go-ipfs-config" inet "github.com/libp2p/go-libp2p-core/network" peer "github.com/libp2p/go-libp2p-core/peer" - swarm "github.com/libp2p/go-libp2p-swarm" - mafilter "github.com/libp2p/go-maddr-filter" ma "github.com/multiformats/go-multiaddr" madns "github.com/multiformats/go-multiaddr-dns" mamask "github.com/whyrusleeping/multiaddr-filter" @@ -559,14 +557,8 @@ Filters default to those specified under the "Swarm.AddrFilters" config key. return ErrNotOnline } - // FIXME(steb) - swrm, ok := n.PeerHost.Network().(*swarm.Swarm) - if !ok { - return errors.New("failed to cast network to swarm network") - } - var output []string - for _, f := range swrm.Filters.FiltersForAction(mafilter.ActionDeny) { + for _, f := range n.Filters.FiltersForAction(ma.ActionDeny) { s, err := mamask.ConvertIPNet(&f) if err != nil { return err @@ -601,12 +593,6 @@ var swarmFiltersAddCmd = &cmds.Command{ return ErrNotOnline } - // FIXME(steb) - swrm, ok := n.PeerHost.Network().(*swarm.Swarm) - if !ok { - return errors.New("failed to cast network to swarm network") - } - if len(req.Arguments) == 0 { return errors.New("no filters to add") } @@ -627,7 +613,7 @@ var swarmFiltersAddCmd = &cmds.Command{ return err } - swrm.Filters.AddFilter(*mask, mafilter.ActionDeny) + n.Filters.AddFilter(*mask, ma.ActionDeny) } added, err := filtersAdd(r, cfg, req.Arguments) @@ -663,11 +649,6 @@ var swarmFiltersRmCmd = &cmds.Command{ return ErrNotOnline } - swrm, ok := n.PeerHost.Network().(*swarm.Swarm) - if !ok { - return errors.New("failed to cast network to swarm network") - } - r, err := fsrepo.Open(env.(*commands.Context).ConfigRoot) if err != nil { return err @@ -679,9 +660,9 @@ var swarmFiltersRmCmd = &cmds.Command{ } if req.Arguments[0] == "all" || req.Arguments[0] == "*" { - fs := swrm.Filters.FiltersForAction(mafilter.ActionDeny) + fs := n.Filters.FiltersForAction(ma.ActionDeny) for _, f := range fs { - swrm.Filters.RemoveLiteral(f) + n.Filters.RemoveLiteral(f) } removed, err := filtersRemoveAll(r, cfg) @@ -698,7 +679,7 @@ var swarmFiltersRmCmd = &cmds.Command{ return err } - swrm.Filters.RemoveLiteral(*mask) + n.Filters.RemoveLiteral(*mask) } removed, err := filtersRemove(r, cfg, req.Arguments) diff --git a/core/core.go b/core/core.go index 6cdf4d921a4..d422a1aa80c 100644 --- a/core/core.go +++ b/core/core.go @@ -39,6 +39,7 @@ import ( record "github.com/libp2p/go-libp2p-record" "github.com/libp2p/go-libp2p/p2p/discovery" p2pbhost "github.com/libp2p/go-libp2p/p2p/host/basic" + ma "github.com/multiformats/go-multiaddr" "github.com/ipfs/go-ipfs/core/bootstrap" "github.com/ipfs/go-ipfs/core/node" @@ -47,6 +48,7 @@ import ( "github.com/ipfs/go-ipfs/namesys" ipnsrp "github.com/ipfs/go-ipfs/namesys/republisher" "github.com/ipfs/go-ipfs/p2p" + "github.com/ipfs/go-ipfs/peering" "github.com/ipfs/go-ipfs/repo" ) @@ -82,6 +84,8 @@ type IpfsNode struct { // Online PeerHost p2phost.Host `optional:"true"` // the network host (server+client) + Peering peering.PeeringService `optional:"true"` + Filters *ma.Filters `optional:"true"` Bootstrapper io.Closer `optional:"true"` // the periodic bootstrapper Routing routing.Routing `optional:"true"` // the routing system. recommend ipfs-dht Exchange exchange.Interface // the block exchange + strategy (bitswap) diff --git a/core/core_test.go b/core/core_test.go index 3a5f7c23682..051b812c11a 100644 --- a/core/core_test.go +++ b/core/core_test.go @@ -20,7 +20,7 @@ func TestInitialization(t *testing.T) { { Identity: id, Addresses: config.Addresses{ - Swarm: []string{"/ip4/0.0.0.0/tcp/4001"}, + Swarm: []string{"/ip4/0.0.0.0/tcp/4001", "/ip4/0.0.0.0/udp/4001/quic"}, API: []string{"/ip4/127.0.0.1/tcp/8000"}, }, }, @@ -28,7 +28,7 @@ func TestInitialization(t *testing.T) { { Identity: id, Addresses: config.Addresses{ - Swarm: []string{"/ip4/0.0.0.0/tcp/4001"}, + Swarm: []string{"/ip4/0.0.0.0/tcp/4001", "/ip4/0.0.0.0/udp/4001/quic"}, API: []string{"/ip4/127.0.0.1/tcp/8000"}, }, }, diff --git a/core/coreapi/dag.go b/core/coreapi/dag.go index ecc4a7408bb..7994842b8e5 100644 --- a/core/coreapi/dag.go +++ b/core/coreapi/dag.go @@ -6,6 +6,7 @@ import ( cid "github.com/ipfs/go-cid" "github.com/ipfs/go-ipfs-pinner" ipld "github.com/ipfs/go-ipld-format" + dag "github.com/ipfs/go-merkledag" ) type dagAPI struct { @@ -50,3 +51,12 @@ func (adder *pinningAdder) AddMany(ctx context.Context, nds []ipld.Node) error { func (api *dagAPI) Pinning() ipld.NodeAdder { return (*pinningAdder)(api.core) } + +func (api *dagAPI) Session(ctx context.Context) ipld.NodeGetter { + return dag.NewSession(ctx, api.DAGService) +} + +var ( + _ ipld.DAGService = (*dagAPI)(nil) + _ dag.SessionMaker = (*dagAPI)(nil) +) diff --git a/core/coreapi/name.go b/core/coreapi/name.go index 4792196b626..ec653a39434 100644 --- a/core/coreapi/name.go +++ b/core/coreapi/name.go @@ -120,6 +120,9 @@ func (api *NameAPI) Search(ctx context.Context, name string, opts ...caopts.Name // Resolve attempts to resolve the newest version of the specified name and // returns its path. func (api *NameAPI) Resolve(ctx context.Context, name string, opts ...caopts.NameResolveOption) (path.Path, error) { + ctx, cancel := context.WithCancel(ctx) + defer cancel() + results, err := api.Search(ctx, name, opts...) if err != nil { return nil, err diff --git a/core/coreapi/pin.go b/core/coreapi/pin.go index 70b69b5b36c..5bd2f9d5af3 100644 --- a/core/coreapi/pin.go +++ b/core/coreapi/pin.go @@ -3,11 +3,11 @@ package coreapi import ( "context" "fmt" + bserv "github.com/ipfs/go-blockservice" "github.com/ipfs/go-cid" offline "github.com/ipfs/go-ipfs-exchange-offline" pin "github.com/ipfs/go-ipfs-pinner" - ipld "github.com/ipfs/go-ipld-format" "github.com/ipfs/go-merkledag" coreiface "github.com/ipfs/interface-go-ipfs-core" caopts "github.com/ipfs/interface-go-ipfs-core/options" @@ -41,7 +41,7 @@ func (api *PinAPI) Add(ctx context.Context, p path.Path, opts ...caopts.PinAddOp return api.pinning.Flush(ctx) } -func (api *PinAPI) Ls(ctx context.Context, opts ...caopts.PinLsOption) ([]coreiface.Pin, error) { +func (api *PinAPI) Ls(ctx context.Context, opts ...caopts.PinLsOption) (<-chan coreiface.Pin, error) { settings, err := caopts.PinLsOptions(opts...) if err != nil { return nil, err @@ -53,7 +53,26 @@ func (api *PinAPI) Ls(ctx context.Context, opts ...caopts.PinLsOption) ([]coreif return nil, fmt.Errorf("invalid type '%s', must be one of {direct, indirect, recursive, all}", settings.Type) } - return api.pinLsAll(settings.Type, ctx) + return api.pinLsAll(ctx, settings.Type), nil +} + +func (api *PinAPI) IsPinned(ctx context.Context, p path.Path, opts ...caopts.PinIsPinnedOption) (string, bool, error) { + dagNode, err := api.core().ResolveNode(ctx, p) + if err != nil { + return "", false, fmt.Errorf("pin: %s", err) + } + + settings, err := caopts.PinIsPinnedOptions(opts...) + if err != nil { + return "", false, err + } + + mode, ok := pin.StringToMode(settings.WithType) + if !ok { + return "", false, fmt.Errorf("invalid type '%s', must be one of {direct, indirect, recursive, all}", settings.WithType) + } + + return api.pinning.IsPinnedWithType(ctx, dagNode.Cid(), mode) } // Rm pin rm api @@ -184,6 +203,7 @@ func (api *PinAPI) Verify(ctx context.Context) (<-chan coreiface.PinStatus, erro type pinInfo struct { pinType string path path.Resolved + err error } func (p *pinInfo) Path() path.Resolved { @@ -194,41 +214,21 @@ func (p *pinInfo) Type() string { return p.pinType } -func (api *PinAPI) pinLsAll(typeStr string, ctx context.Context) ([]coreiface.Pin, error) { - pinCh, errCh := PinLsAll(ctx, typeStr, api.pinning, api.dag) - - var pins []coreiface.Pin -loop: - for { - select { - case p, ok := <-pinCh: - if !ok { - break loop - } - pins = append(pins, p) - case <-ctx.Done(): - return nil, ctx.Err() - } - } - err := <-errCh - if err != nil { - return nil, err - } - - return pins, nil +func (p *pinInfo) Err() error { + return p.err } -// PinLsAll is an internal function for returning a list of pins -func PinLsAll(ctx context.Context, typeStr string, pin pin.Pinner, dag ipld.DAGService) (chan coreiface.Pin, chan error) { - ch := make(chan coreiface.Pin, 32) - errCh := make(chan error, 1) +// pinLsAll is an internal function for returning a list of pins +func (api *PinAPI) pinLsAll(ctx context.Context, typeStr string) <-chan coreiface.Pin { + out := make(chan coreiface.Pin) keys := cid.NewSet() + AddToResultKeys := func(keyList []cid.Cid, typeStr string) error { for _, c := range keyList { if keys.Visit(c) { select { - case ch <- &pinInfo{ + case out <- &pinInfo{ pinType: typeStr, path: path.IpldPath(c), }: @@ -240,77 +240,98 @@ func PinLsAll(ctx context.Context, typeStr string, pin pin.Pinner, dag ipld.DAGS return nil } + VisitKeys := func(keyList []cid.Cid) { + for _, c := range keyList { + keys.Visit(c) + } + } + go func() { - defer close(ch) - defer close(errCh) - if typeStr == "direct" || typeStr == "all" { - dkeys, err := pin.DirectKeys(ctx) + defer close(out) + + if typeStr == "recursive" || typeStr == "all" { + rkeys, err := api.pinning.RecursiveKeys(ctx) if err != nil { - errCh <- err + out <- &pinInfo{err: err} return } - if err := AddToResultKeys(dkeys, "direct"); err != nil { - errCh <- err + if err := AddToResultKeys(rkeys, "recursive"); err != nil { + out <- &pinInfo{err: err} return } } - if typeStr == "recursive" || typeStr == "all" { - rkeys, err := pin.RecursiveKeys(ctx) + if typeStr == "direct" || typeStr == "all" { + dkeys, err := api.pinning.DirectKeys(ctx) if err != nil { - errCh <- err + out <- &pinInfo{err: err} return } - if err := AddToResultKeys(rkeys, "recursive"); err != nil { - errCh <- err + if err := AddToResultKeys(dkeys, "direct"); err != nil { + out <- &pinInfo{err: err} return } } - if typeStr == "indirect" || typeStr == "all" { - rkeys, err := pin.RecursiveKeys(ctx) + if typeStr == "all" { + set := cid.NewSet() + rkeys, err := api.pinning.RecursiveKeys(ctx) if err != nil { - errCh <- err + out <- &pinInfo{err: err} return } - - // If we're only listing indirect pins, we need to - // explicitly mark direct/recursive pins so we don't - // send them. - if typeStr == "indirect" { - dkeys, err := pin.DirectKeys(ctx) + for _, k := range rkeys { + err := merkledag.Walk( + ctx, merkledag.GetLinksWithDAG(api.dag), k, + set.Visit, + merkledag.SkipRoot(), merkledag.Concurrent(), + ) if err != nil { - errCh <- err + out <- &pinInfo{err: err} return } + } + if err := AddToResultKeys(set.Keys(), "indirect"); err != nil { + out <- &pinInfo{err: err} + return + } + } + if typeStr == "indirect" { + // We need to first visit the direct pins that have priority + // without emitting them - for _, k := range dkeys { - keys.Add(k) - } - for _, k := range rkeys { - keys.Add(k) - } + dkeys, err := api.pinning.DirectKeys(ctx) + if err != nil { + out <- &pinInfo{err: err} + return } + VisitKeys(dkeys) - indirectKeys := cid.NewSet() - for _, k := range rkeys { - err := merkledag.Walk(ctx, merkledag.GetLinksWithDAG(dag), k, func(c cid.Cid) bool { - r := indirectKeys.Visit(c) - if r { - if err := AddToResultKeys([]cid.Cid{c}, "indirect"); err != nil { - return false - } - } - return r - }, merkledag.SkipRoot(), merkledag.Concurrent()) + rkeys, err := api.pinning.RecursiveKeys(ctx) + if err != nil { + out <- &pinInfo{err: err} + return + } + VisitKeys(rkeys) + set := cid.NewSet() + for _, k := range rkeys { + err := merkledag.Walk( + ctx, merkledag.GetLinksWithDAG(api.dag), k, + set.Visit, + merkledag.SkipRoot(), merkledag.Concurrent(), + ) if err != nil { - errCh <- err + out <- &pinInfo{err: err} return } } + if err := AddToResultKeys(set.Keys(), "indirect"); err != nil { + out <- &pinInfo{err: err} + return + } } }() - return ch, errCh + return out } func (api *PinAPI) core() coreiface.CoreAPI { diff --git a/core/corehttp/gateway_handler.go b/core/corehttp/gateway_handler.go index f91d42b6160..a1549efddb6 100644 --- a/core/corehttp/gateway_handler.go +++ b/core/corehttp/gateway_handler.go @@ -11,12 +11,15 @@ import ( gopath "path" "regexp" "runtime/debug" + "strconv" "strings" "time" humanize "github.com/dustin/go-humanize" + "github.com/gabriel-vasile/mimetype" "github.com/ipfs/go-cid" files "github.com/ipfs/go-ipfs-files" + assets "github.com/ipfs/go-ipfs/assets" dag "github.com/ipfs/go-merkledag" mfs "github.com/ipfs/go-mfs" path "github.com/ipfs/go-path" @@ -202,6 +205,10 @@ func (i *gatewayHandler) getOrHeadHandler(w http.ResponseWriter, r *http.Request webError(w, "ipfs resolve -r "+escapedURLPath, err, http.StatusServiceUnavailable) return default: + if i.servePretty404IfPresent(w, r, parsedPath) { + return + } + webError(w, "ipfs resolve -r "+escapedURLPath, err, http.StatusNotFound) return } @@ -216,16 +223,26 @@ func (i *gatewayHandler) getOrHeadHandler(w http.ResponseWriter, r *http.Request defer dr.Close() - // Check etag send back to us - etag := "\"" + resolvedPath.Cid().String() + "\"" - if r.Header.Get("If-None-Match") == etag || r.Header.Get("If-None-Match") == "W/"+etag { + var responseEtag string + + // we need to figure out whether this is a directory before doing most of the heavy lifting below + _, ok := dr.(files.Directory) + + if ok && assets.BindataVersionHash != "" { + responseEtag = `"DirIndex-` + assets.BindataVersionHash + `_CID-` + resolvedPath.Cid().String() + `"` + } else { + responseEtag = `"` + resolvedPath.Cid().String() + `"` + } + + // Check etag sent back to us + if r.Header.Get("If-None-Match") == responseEtag || r.Header.Get("If-None-Match") == `W/`+responseEtag { w.WriteHeader(http.StatusNotModified) return } i.addUserHeaders(w) // ok, _now_ write user's headers. w.Header().Set("X-IPFS-Path", urlPath) - w.Header().Set("Etag", etag) + w.Header().Set("Etag", responseEtag) // set these headers _after_ the error, for we may just not have it // and don't want the client to cache a 500 response... @@ -285,6 +302,18 @@ func (i *gatewayHandler) getOrHeadHandler(w http.ResponseWriter, r *http.Request return } + // See statusResponseWriter.WriteHeader + // and https://github.com/ipfs/go-ipfs/issues/7164 + // Note: this needs to occur before listingTemplate.Execute otherwise we get + // superfluous response.WriteHeader call from prometheus/client_golang + if w.Header().Get("Location") != "" { + w.WriteHeader(http.StatusMovedPermanently) + return + } + + // A HTML directory index will be presented, be sure to set the correct + // type instead of relying on autodetection (which may fail). + w.Header().Set("Content-Type", "text/html") if r.Method == http.MethodHead { return } @@ -330,28 +359,16 @@ func (i *gatewayHandler) getOrHeadHandler(w http.ResponseWriter, r *http.Request } } - var hash string - if !strings.HasPrefix(urlPath, ipfsPathPrefix) { - hash = resolvedPath.Cid().String() - } + hash := resolvedPath.Cid().String() // See comment above where originalUrlPath is declared. tplData := listingTemplateData{ Listing: dirListing, - Path: originalUrlPath, + Path: urlPath, BackLink: backLink, Hash: hash, } - // See statusResponseWriter.WriteHeader - // and https://github.com/ipfs/go-ipfs/issues/7164 - // Note: this needs to occur before listingTemplate.Execute otherwise we get - // superfluous response.WriteHeader call from prometheus/client_golang - if w.Header().Get("Location") != "" { - w.WriteHeader(http.StatusMovedPermanently) - return - } - err = listingTemplate.Execute(w, tplData) if err != nil { internalWebError(w, err) @@ -379,10 +396,16 @@ func (i *gatewayHandler) serveFile(w http.ResponseWriter, req *http.Request, nam } else { ctype = mime.TypeByExtension(gopath.Ext(name)) if ctype == "" { - buf := make([]byte, 512) - n, _ := io.ReadFull(content, buf[:]) - ctype = http.DetectContentType(buf[:n]) - _, err := content.Seek(0, io.SeekStart) + // uses https://github.com/gabriel-vasile/mimetype library to determine the content type. + // Fixes https://github.com/ipfs/go-ipfs/issues/7252 + mimeType, err := mimetype.DetectReader(content) + if err != nil { + http.Error(w, fmt.Sprintf("cannot detect content-type: %s", err.Error()), http.StatusInternalServerError) + return + } + + ctype = mimeType.String() + _, err = content.Seek(0, io.SeekStart) if err != nil { http.Error(w, "seeker can't seek", http.StatusInternalServerError) return @@ -402,6 +425,36 @@ func (i *gatewayHandler) serveFile(w http.ResponseWriter, req *http.Request, nam http.ServeContent(w, req, name, modtime, content) } +func (i *gatewayHandler) servePretty404IfPresent(w http.ResponseWriter, r *http.Request, parsedPath ipath.Path) bool { + resolved404Path, ctype, err := i.searchUpTreeFor404(r, parsedPath) + if err != nil { + return false + } + + dr, err := i.api.Unixfs().Get(r.Context(), resolved404Path) + if err != nil { + return false + } + defer dr.Close() + + f, ok := dr.(files.File) + if !ok { + return false + } + + size, err := f.Size() + if err != nil { + return false + } + + log.Debugf("using pretty 404 file for %s", parsedPath.String()) + w.Header().Set("Content-Type", ctype) + w.Header().Set("Content-Length", strconv.FormatInt(size, 10)) + w.WriteHeader(http.StatusNotFound) + _, err = io.CopyN(w, f, size) + return err == nil +} + func (i *gatewayHandler) postHandler(w http.ResponseWriter, r *http.Request) { p, err := i.api.Unixfs().Add(r.Context(), files.NewReaderFile(r.Body)) if err != nil { @@ -615,3 +668,45 @@ func getFilename(s string) string { } return gopath.Base(s) } + +func (i *gatewayHandler) searchUpTreeFor404(r *http.Request, parsedPath ipath.Path) (ipath.Resolved, string, error) { + filename404, ctype, err := preferred404Filename(r.Header.Values("Accept")) + if err != nil { + return nil, "", err + } + + pathComponents := strings.Split(parsedPath.String(), "/") + + for idx := len(pathComponents); idx >= 3; idx-- { + pretty404 := gopath.Join(append(pathComponents[0:idx], filename404)...) + parsed404Path := ipath.New("/" + pretty404) + if parsed404Path.IsValid() != nil { + break + } + resolvedPath, err := i.api.ResolvePath(r.Context(), parsed404Path) + if err != nil { + continue + } + return resolvedPath, ctype, nil + } + + return nil, "", fmt.Errorf("no pretty 404 in any parent folder") +} + +func preferred404Filename(acceptHeaders []string) (string, string, error) { + // If we ever want to offer a 404 file for a different content type + // then this function will need to parse q weightings, but for now + // the presence of anything matching HTML is enough. + for _, acceptHeader := range acceptHeaders { + accepted := strings.Split(acceptHeader, ",") + for _, spec := range accepted { + contentType := strings.SplitN(spec, ";", 1)[0] + switch contentType { + case "*/*", "text/*", "text/html": + return "ipfs-404.html", "text/html", nil + } + } + } + + return "", "", fmt.Errorf("there is no 404 file for the requested content types") +} diff --git a/core/corehttp/gateway_test.go b/core/corehttp/gateway_test.go index daf1af07c6c..a8a07aa48d3 100644 --- a/core/corehttp/gateway_test.go +++ b/core/corehttp/gateway_test.go @@ -235,6 +235,70 @@ func TestGatewayGet(t *testing.T) { } } +func TestPretty404(t *testing.T) { + ns := mockNamesys{} + ts, api, ctx := newTestServerAndNode(t, ns) + defer ts.Close() + + f1 := files.NewMapDirectory(map[string]files.Node{ + "ipfs-404.html": files.NewBytesFile([]byte("Custom 404")), + "deeper": files.NewMapDirectory(map[string]files.Node{ + "ipfs-404.html": files.NewBytesFile([]byte("Deep custom 404")), + }), + }) + + k, err := api.Unixfs().Add(ctx, f1) + if err != nil { + t.Fatal(err) + } + + host := "example.net" + ns["/ipns/"+host] = path.FromString(k.String()) + + for _, test := range []struct { + path string + accept string + status int + text string + }{ + {"/ipfs-404.html", "text/html", http.StatusOK, "Custom 404"}, + {"/nope", "text/html", http.StatusNotFound, "Custom 404"}, + {"/nope", "text/*", http.StatusNotFound, "Custom 404"}, + {"/nope", "*/*", http.StatusNotFound, "Custom 404"}, + {"/nope", "application/json", http.StatusNotFound, "ipfs resolve -r /ipns/example.net/nope: no link named \"nope\" under QmcmnF7XG5G34RdqYErYDwCKNFQ6jb8oKVR21WAJgubiaj\n"}, + {"/deeper/nope", "text/html", http.StatusNotFound, "Deep custom 404"}, + {"/deeper/", "text/html", http.StatusOK, ""}, + {"/deeper", "text/html", http.StatusOK, ""}, + {"/nope/nope", "text/html", http.StatusNotFound, "Custom 404"}, + } { + var c http.Client + req, err := http.NewRequest("GET", ts.URL+test.path, nil) + if err != nil { + t.Fatal(err) + } + req.Header.Add("Accept", test.accept) + req.Host = host + resp, err := c.Do(req) + + if err != nil { + t.Fatalf("error requesting %s: %s", test.path, err) + } + + defer resp.Body.Close() + if resp.StatusCode != test.status { + t.Fatalf("got %d, expected %d, from %s", resp.StatusCode, test.status, test.path) + } + body, err := ioutil.ReadAll(resp.Body) + if err != nil { + t.Fatalf("error reading response from %s: %s", test.path, err) + } + + if test.text != "" && string(body) != test.text { + t.Fatalf("unexpected response body from %s: got %q, expected %q", test.path, body, test.text) + } + } +} + func TestIPNSHostnameRedirect(t *testing.T) { ns := mockNamesys{} ts, api, ctx := newTestServerAndNode(t, ns) @@ -378,7 +442,7 @@ func TestIPNSHostnameBacklinks(t *testing.T) { s := string(body) t.Logf("body: %s\n", string(body)) - if !strings.Contains(s, "Index of /foo? #<'/") { + if !strings.Contains(s, "Index of /ipns/example.net/foo? #<'/") { t.Fatalf("expected a path in directory listing") } if !strings.Contains(s, "") { @@ -444,7 +508,7 @@ func TestIPNSHostnameBacklinks(t *testing.T) { s = string(body) t.Logf("body: %s\n", string(body)) - if !strings.Contains(s, "Index of /foo? #<'/bar/") { + if !strings.Contains(s, "Index of /ipns/example.net/foo? #<'/bar/") { t.Fatalf("expected a path in directory listing") } if !strings.Contains(s, "") { @@ -478,7 +542,7 @@ func TestIPNSHostnameBacklinks(t *testing.T) { s = string(body) t.Logf("body: %s\n", string(body)) - if !strings.Contains(s, "Index of /good-prefix") { + if !strings.Contains(s, "Index of /ipns/example.net") { t.Fatalf("expected a path in directory listing") } if !strings.Contains(s, "") { diff --git a/core/corehttp/hostname.go b/core/corehttp/hostname.go index 143435106e5..d8656da23ec 100644 --- a/core/corehttp/hostname.go +++ b/core/corehttp/hostname.go @@ -124,7 +124,7 @@ func HostnameOption() ServeOption { // Not a whitelisted path // Try DNSLink, if it was not explicitly disabled for the hostname - if !gw.NoDNSLink && isDNSLinkRequest(n.Context(), coreApi, r) { + if !gw.NoDNSLink && isDNSLinkRequest(r.Context(), coreApi, r) { // rewrite path and handle as DNSLink r.URL.Path = "/ipns/" + stripPort(r.Host) + r.URL.Path childMux.ServeHTTP(w, r) @@ -176,7 +176,7 @@ func HostnameOption() ServeOption { // 1. is wildcard DNSLink enabled (Gateway.NoDNSLink=false)? // 2. does Host header include a fully qualified domain name (FQDN)? // 3. does DNSLink record exist in DNS? - if !cfg.Gateway.NoDNSLink && isDNSLinkRequest(n.Context(), coreApi, r) { + if !cfg.Gateway.NoDNSLink && isDNSLinkRequest(r.Context(), coreApi, r) { // rewrite path and handle as DNSLink r.URL.Path = "/ipns/" + stripPort(r.Host) + r.URL.Path childMux.ServeHTTP(w, r) diff --git a/core/corehttp/webui.go b/core/corehttp/webui.go index 02f2da73ad9..f94df7850f0 100644 --- a/core/corehttp/webui.go +++ b/core/corehttp/webui.go @@ -1,11 +1,13 @@ package corehttp // TODO: move to IPNS -const WebUIPath = "/ipfs/bafybeidatpz2hli6fgu3zul5woi27ujesdf5o5a7bu622qj6ugharciwjq" +const WebUIPath = "/ipfs/bafybeigkbbjnltbd4ewfj7elajsbnjwinyk6tiilczkqsibf3o7dcr6nn4" // v2.9.0 // this is a list of all past webUI paths. var WebUIPaths = []string{ WebUIPath, + "/ipfs/bafybeicp23nbcxtt2k2twyfivcbrc6kr3l5lnaiv3ozvwbemtrb7v52r6i", + "/ipfs/bafybeidatpz2hli6fgu3zul5woi27ujesdf5o5a7bu622qj6ugharciwjq", "/ipfs/QmfQkD8pBSBCBxWEwFSu4XaDVSWK6bjnNuaWZjMyQbyDub", "/ipfs/QmXc9raDM1M5G5fpBnVyQ71vR4gbnskwnB9iMEzBuLgvoZ", "/ipfs/QmenEBWcAk3tN94fSKpKFtUMwty1qNwSYw3DMDFV6cPBXA", diff --git a/core/node/builder.go b/core/node/builder.go index 2dd1986ca3c..22ab500e150 100644 --- a/core/node/builder.go +++ b/core/node/builder.go @@ -140,7 +140,7 @@ func defaultRepo(dstore repo.Datastore) (repo.Repo, error) { } c.Bootstrap = cfg.DefaultBootstrapAddresses - c.Addresses.Swarm = []string{"/ip4/0.0.0.0/tcp/4001"} + c.Addresses.Swarm = []string{"/ip4/0.0.0.0/tcp/4001", "/ip4/0.0.0.0/udp/4001/quic"} c.Identity.PeerID = pid.Pretty() c.Identity.PrivKey = base64.StdEncoding.EncodeToString(privkeyb) diff --git a/core/node/groups.go b/core/node/groups.go index f94d97634b1..90245ba0517 100644 --- a/core/node/groups.go +++ b/core/node/groups.go @@ -9,6 +9,7 @@ import ( blockstore "github.com/ipfs/go-ipfs-blockstore" config "github.com/ipfs/go-ipfs-config" util "github.com/ipfs/go-ipfs-util" + log "github.com/ipfs/go-log" peer "github.com/libp2p/go-libp2p-core/peer" pubsub "github.com/libp2p/go-libp2p-pubsub" @@ -22,12 +23,12 @@ import ( "go.uber.org/fx" ) +var logger = log.Logger("core:constructor") + var BaseLibP2P = fx.Options( fx.Provide(libp2p.UserAgent), fx.Provide(libp2p.PNet), fx.Provide(libp2p.ConnectionManager), - fx.Provide(libp2p.DefaultTransports), - fx.Provide(libp2p.Host), fx.Provide(libp2p.DiscoveryHandler), @@ -75,7 +76,6 @@ func LibP2P(bcfg *BuildCfg, cfg *config.Config) fx.Option { pubsubOptions = append( pubsubOptions, pubsub.WithMessageSigning(!cfg.Pubsub.DisableSigning), - pubsub.WithStrictSignatureVerification(cfg.Pubsub.StrictSignatureVerification), ) switch cfg.Pubsub.Router { @@ -109,19 +109,33 @@ func LibP2P(bcfg *BuildCfg, cfg *config.Config) fx.Option { autonat = fx.Provide(libp2p.AutoNATService(cfg.AutoNAT.Throttle)) } - // Gather all the options + // If `cfg.Swarm.DisableRelay` is set and `Network.Relay` isn't, use the former. + enableRelay := cfg.Swarm.Transports.Network.Relay.WithDefault(!cfg.Swarm.DisableRelay) //nolint + + // Warn about a deprecated option. + //nolint + if cfg.Swarm.DisableRelay { + logger.Error("The `Swarm.DisableRelay' config field is deprecated.") + if enableRelay { + logger.Error("`Swarm.DisableRelay' has been overridden by `Swarm.Transports.Network.Relay'") + } else { + logger.Error("Use the `Swarm.Transports.Network.Relay' config field instead") + } + } + // Gather all the options opts := fx.Options( BaseLibP2P, fx.Provide(libp2p.AddrFilters(cfg.Swarm.AddrFilters)), fx.Provide(libp2p.AddrsFactory(cfg.Addresses.Announce, cfg.Addresses.NoAnnounce)), - fx.Provide(libp2p.SmuxTransport(bcfg.getOpt("mplex"))), - fx.Provide(libp2p.Relay(cfg.Swarm.DisableRelay, cfg.Swarm.EnableRelayHop)), + fx.Provide(libp2p.SmuxTransport(cfg.Swarm.Transports)), + fx.Provide(libp2p.Relay(enableRelay, cfg.Swarm.EnableRelayHop)), + fx.Provide(libp2p.Transports(cfg.Swarm.Transports)), fx.Invoke(libp2p.StartListening(cfg.Addresses.Swarm)), fx.Invoke(libp2p.SetupDiscovery(cfg.Discovery.MDNS.Enabled, cfg.Discovery.MDNS.Interval)), - fx.Provide(libp2p.Security(!bcfg.DisableEncryptedConnections)), + fx.Provide(libp2p.Security(!bcfg.DisableEncryptedConnections, cfg.Swarm.Transports)), fx.Provide(libp2p.Routing), fx.Provide(libp2p.BaseRouting), @@ -130,7 +144,6 @@ func LibP2P(bcfg *BuildCfg, cfg *config.Config) fx.Option { maybeProvide(libp2p.BandwidthCounter, !cfg.Swarm.DisableBandwidthMetrics), maybeProvide(libp2p.NatPortMap, !cfg.Swarm.DisableNatPortMap), maybeProvide(libp2p.AutoRelay, cfg.Swarm.EnableAutoRelay), - maybeProvide(libp2p.QUIC, cfg.Experimental.QUIC), autonat, connmgr, ps, @@ -252,6 +265,8 @@ func Online(bcfg *BuildCfg, cfg *config.Config) fx.Option { fx.Provide(OnlineExchange(shouldBitswapProvide)), maybeProvide(Graphsync, cfg.Experimental.GraphsyncEnabled), fx.Provide(Namesys(ipnsCacheSize)), + fx.Provide(Peering), + PeerWith(cfg.Peering.Peers...), fx.Invoke(IpnsRepublisher(repubPeriod, recordLifetime)), diff --git a/core/node/libp2p/addrs.go b/core/node/libp2p/addrs.go index 703a959cbae..f64947130d6 100644 --- a/core/node/libp2p/addrs.go +++ b/core/node/libp2p/addrs.go @@ -6,21 +6,22 @@ import ( "github.com/libp2p/go-libp2p" host "github.com/libp2p/go-libp2p-core/host" p2pbhost "github.com/libp2p/go-libp2p/p2p/host/basic" - mafilter "github.com/libp2p/go-maddr-filter" ma "github.com/multiformats/go-multiaddr" mamask "github.com/whyrusleeping/multiaddr-filter" ) -func AddrFilters(filters []string) func() (opts Libp2pOpts, err error) { - return func() (opts Libp2pOpts, err error) { +func AddrFilters(filters []string) func() (*ma.Filters, Libp2pOpts, error) { + return func() (filter *ma.Filters, opts Libp2pOpts, err error) { + filter = ma.NewFilters() + opts.Opts = append(opts.Opts, libp2p.Filters(filter)) //nolint for _, s := range filters { f, err := mamask.NewMask(s) if err != nil { - return opts, fmt.Errorf("incorrectly formatted address filter in config: %s", s) + return filter, opts, fmt.Errorf("incorrectly formatted address filter in config: %s", s) } - opts.Opts = append(opts.Opts, libp2p.FilterAddresses(f)) + opts.Opts = append(opts.Opts, libp2p.FilterAddresses(f)) //nolint } - return opts, nil + return filter, opts, nil } } @@ -34,12 +35,12 @@ func makeAddrsFactory(announce []string, noAnnounce []string) (p2pbhost.AddrsFac annAddrs = append(annAddrs, maddr) } - filters := mafilter.NewFilters() + filters := ma.NewFilters() noAnnAddrs := map[string]bool{} for _, addr := range noAnnounce { f, err := mamask.NewMask(addr) if err == nil { - filters.AddFilter(*f, mafilter.ActionDeny) + filters.AddFilter(*f, ma.ActionDeny) continue } maddr, err := ma.NewMultiaddr(addr) diff --git a/core/node/libp2p/host.go b/core/node/libp2p/host.go index 57475316e35..4005f0a7e74 100644 --- a/core/node/libp2p/host.go +++ b/core/node/libp2p/host.go @@ -10,10 +10,11 @@ import ( routing "github.com/libp2p/go-libp2p-core/routing" record "github.com/libp2p/go-libp2p-record" routedhost "github.com/libp2p/go-libp2p/p2p/host/routed" - "go.uber.org/fx" "github.com/ipfs/go-ipfs/core/node/helpers" "github.com/ipfs/go-ipfs/repo" + + "go.uber.org/fx" ) type P2PHostIn struct { @@ -43,9 +44,22 @@ func Host(mctx helpers.MetricsCtx, lc fx.Lifecycle, params P2PHostIn) (out P2PHo } ctx := helpers.LifecycleCtx(mctx, lc) + cfg, err := params.Repo.Config() + if err != nil { + return out, err + } + bootstrappers, err := cfg.BootstrapPeers() + if err != nil { + return out, err + } opts = append(opts, libp2p.Routing(func(h host.Host) (routing.PeerRouting, error) { - r, err := params.RoutingOption(ctx, h, params.Repo.Datastore(), params.Validator) + r, err := params.RoutingOption( + ctx, h, + params.Repo.Datastore(), + params.Validator, + bootstrappers..., + ) out.Routing = r return r, err })) @@ -58,7 +72,7 @@ func Host(mctx helpers.MetricsCtx, lc fx.Lifecycle, params P2PHostIn) (out P2PHo // this code is necessary just for tests: mock network constructions // ignore the libp2p constructor options that actually construct the routing! if out.Routing == nil { - r, err := params.RoutingOption(ctx, out.Host, params.Repo.Datastore(), params.Validator) + r, err := params.RoutingOption(ctx, out.Host, params.Repo.Datastore(), params.Validator, bootstrappers...) if err != nil { return P2PHostOut{}, err } diff --git a/core/node/libp2p/libp2p.go b/core/node/libp2p/libp2p.go index d9b0b5f5558..51183c9543a 100644 --- a/core/node/libp2p/libp2p.go +++ b/core/node/libp2p/libp2p.go @@ -1,9 +1,11 @@ package libp2p import ( + "sort" "time" version "github.com/ipfs/go-ipfs" + config "github.com/ipfs/go-ipfs-config" logging "github.com/ipfs/go-log" "github.com/libp2p/go-libp2p" @@ -48,3 +50,32 @@ func simpleOpt(opt libp2p.Option) func() (opts Libp2pOpts, err error) { return } } + +type priorityOption struct { + priority, defaultPriority config.Priority + opt libp2p.Option +} + +func prioritizeOptions(opts []priorityOption) libp2p.Option { + type popt struct { + priority int64 + opt libp2p.Option + } + enabledOptions := make([]popt, 0, len(opts)) + for _, o := range opts { + if prio, ok := o.priority.WithDefault(o.defaultPriority); ok { + enabledOptions = append(enabledOptions, popt{ + priority: prio, + opt: o.opt, + }) + } + } + sort.Slice(enabledOptions, func(i, j int) bool { + return enabledOptions[i].priority > enabledOptions[j].priority + }) + p2pOpts := make([]libp2p.Option, len(enabledOptions)) + for i, opt := range enabledOptions { + p2pOpts[i] = opt.opt + } + return libp2p.ChainOptions(p2pOpts...) +} diff --git a/core/node/libp2p/relay.go b/core/node/libp2p/relay.go index d27466dbfd2..e625b4d001c 100644 --- a/core/node/libp2p/relay.go +++ b/core/node/libp2p/relay.go @@ -5,17 +5,16 @@ import ( relay "github.com/libp2p/go-libp2p-circuit" ) -func Relay(disable, enableHop bool) func() (opts Libp2pOpts, err error) { +func Relay(enableRelay, enableHop bool) func() (opts Libp2pOpts, err error) { return func() (opts Libp2pOpts, err error) { - if disable { - // Enabled by default. - opts.Opts = append(opts.Opts, libp2p.DisableRelay()) - } else { + if enableRelay { relayOpts := []relay.RelayOpt{} if enableHop { relayOpts = append(relayOpts, relay.OptHop) } opts.Opts = append(opts.Opts, libp2p.EnableRelay(relayOpts...)) + } else { + opts.Opts = append(opts.Opts, libp2p.DisableRelay()) } return } diff --git a/core/node/libp2p/routingopt.go b/core/node/libp2p/routingopt.go index b673290015a..12527d162ab 100644 --- a/core/node/libp2p/routingopt.go +++ b/core/node/libp2p/routingopt.go @@ -4,31 +4,61 @@ import ( "context" "github.com/ipfs/go-datastore" - nilrouting "github.com/ipfs/go-ipfs-routing/none" host "github.com/libp2p/go-libp2p-core/host" + "github.com/libp2p/go-libp2p-core/peer" routing "github.com/libp2p/go-libp2p-core/routing" dht "github.com/libp2p/go-libp2p-kad-dht" dual "github.com/libp2p/go-libp2p-kad-dht/dual" record "github.com/libp2p/go-libp2p-record" + routinghelpers "github.com/libp2p/go-libp2p-routing-helpers" ) -type RoutingOption func(context.Context, host.Host, datastore.Batching, record.Validator) (routing.Routing, error) +type RoutingOption func( + context.Context, + host.Host, + datastore.Batching, + record.Validator, + ...peer.AddrInfo, +) (routing.Routing, error) -func constructDHTRouting(mode dht.ModeOpt) func(ctx context.Context, host host.Host, dstore datastore.Batching, validator record.Validator) (routing.Routing, error) { - return func(ctx context.Context, host host.Host, dstore datastore.Batching, validator record.Validator) (routing.Routing, error) { +func constructDHTRouting(mode dht.ModeOpt) func( + ctx context.Context, + host host.Host, + dstore datastore.Batching, + validator record.Validator, + bootstrapPeers ...peer.AddrInfo, +) (routing.Routing, error) { + return func( + ctx context.Context, + host host.Host, + dstore datastore.Batching, + validator record.Validator, + bootstrapPeers ...peer.AddrInfo, + ) (routing.Routing, error) { return dual.New( ctx, host, dht.Concurrency(10), dht.Mode(mode), dht.Datastore(dstore), dht.Validator(validator), + dht.BootstrapPeers(bootstrapPeers...), ) } } +func constructNilRouting( + ctx context.Context, + host host.Host, + dstore datastore.Batching, + validator record.Validator, + bootstrapPeers ...peer.AddrInfo, +) (routing.Routing, error) { + return routinghelpers.Null{}, nil +} + var ( DHTOption RoutingOption = constructDHTRouting(dht.ModeAuto) DHTClientOption = constructDHTRouting(dht.ModeClient) DHTServerOption = constructDHTRouting(dht.ModeServer) - NilRouterOption = nilrouting.ConstructNilRouting + NilRouterOption = constructNilRouting ) diff --git a/core/node/libp2p/sec.go b/core/node/libp2p/sec.go new file mode 100644 index 00000000000..9e4d6640e49 --- /dev/null +++ b/core/node/libp2p/sec.go @@ -0,0 +1,38 @@ +package libp2p + +import ( + config "github.com/ipfs/go-ipfs-config" + "github.com/libp2p/go-libp2p" + noise "github.com/libp2p/go-libp2p-noise" + secio "github.com/libp2p/go-libp2p-secio" + tls "github.com/libp2p/go-libp2p-tls" +) + +func Security(enabled bool, tptConfig config.Transports) interface{} { + if !enabled { + return func() (opts Libp2pOpts) { + log.Errorf(`Your IPFS node has been configured to run WITHOUT ENCRYPTED CONNECTIONS. + You will not be able to connect to any nodes configured to use encrypted connections`) + opts.Opts = append(opts.Opts, libp2p.NoSecurity) + return opts + } + } + + // Using the new config options. + return func() (opts Libp2pOpts) { + opts.Opts = append(opts.Opts, prioritizeOptions([]priorityOption{{ + priority: tptConfig.Security.TLS, + defaultPriority: 100, + opt: libp2p.Security(tls.ID, tls.New), + }, { + priority: tptConfig.Security.SECIO, + defaultPriority: 200, + opt: libp2p.Security(secio.ID, secio.New), + }, { + priority: tptConfig.Security.Noise, + defaultPriority: 300, + opt: libp2p.Security(noise.ID, noise.New), + }})) + return opts + } +} diff --git a/core/node/libp2p/smux.go b/core/node/libp2p/smux.go index e89e0095652..8ce540109ce 100644 --- a/core/node/libp2p/smux.go +++ b/core/node/libp2p/smux.go @@ -1,54 +1,79 @@ package libp2p import ( + "fmt" "os" "strings" + config "github.com/ipfs/go-ipfs-config" "github.com/libp2p/go-libp2p" smux "github.com/libp2p/go-libp2p-core/mux" mplex "github.com/libp2p/go-libp2p-mplex" yamux "github.com/libp2p/go-libp2p-yamux" ) -func makeSmuxTransportOption(mplexExp bool) libp2p.Option { +func yamuxTransport() smux.Multiplexer { + tpt := *yamux.DefaultTransport + tpt.AcceptBacklog = 512 + if os.Getenv("YAMUX_DEBUG") != "" { + tpt.LogOutput = os.Stderr + } + + return &tpt +} + +func makeSmuxTransportOption(tptConfig config.Transports) (libp2p.Option, error) { const yamuxID = "/yamux/1.0.0" const mplexID = "/mplex/6.7.0" ymxtpt := *yamux.DefaultTransport ymxtpt.AcceptBacklog = 512 - if os.Getenv("YAMUX_DEBUG") != "" { - ymxtpt.LogOutput = os.Stderr - } - - muxers := map[string]smux.Multiplexer{yamuxID: &ymxtpt} - if mplexExp { - muxers[mplexID] = mplex.DefaultTransport - } - - // Allow muxer preference order overriding - order := []string{yamuxID, mplexID} if prefs := os.Getenv("LIBP2P_MUX_PREFS"); prefs != "" { - order = strings.Fields(prefs) - } + // Using legacy LIBP2P_MUX_PREFS variable. + log.Error("LIBP2P_MUX_PREFS is now deprecated.") + log.Error("Use the `Swarm.Transports.Multiplexers' config field.") + muxers := strings.Fields(prefs) + enabled := make(map[string]bool, len(muxers)) - opts := make([]libp2p.Option, 0, len(order)) - for _, id := range order { - tpt, ok := muxers[id] - if !ok { - log.Warn("unknown or duplicate muxer in LIBP2P_MUX_PREFS: %s", id) - continue + var opts []libp2p.Option + for _, tpt := range muxers { + if enabled[tpt] { + return nil, fmt.Errorf( + "duplicate muxer found in LIBP2P_MUX_PREFS: %s", + tpt, + ) + } + switch tpt { + case yamuxID: + opts = append(opts, libp2p.Muxer(tpt, yamuxTransport)) + case mplexID: + opts = append(opts, libp2p.Muxer(tpt, mplex.DefaultTransport)) + default: + return nil, fmt.Errorf("unknown muxer: %s", tpt) + } } - delete(muxers, id) - opts = append(opts, libp2p.Muxer(id, tpt)) + return libp2p.ChainOptions(opts...), nil + } else { + return prioritizeOptions([]priorityOption{{ + priority: tptConfig.Multiplexers.Yamux, + defaultPriority: 100, + opt: libp2p.Muxer(yamuxID, yamuxTransport), + }, { + priority: tptConfig.Multiplexers.Mplex, + defaultPriority: 200, + opt: libp2p.Muxer(mplexID, mplex.DefaultTransport), + }}), nil } - - return libp2p.ChainOptions(opts...) } -func SmuxTransport(mplex bool) func() (opts Libp2pOpts, err error) { +func SmuxTransport(tptConfig config.Transports) func() (opts Libp2pOpts, err error) { return func() (opts Libp2pOpts, err error) { - opts.Opts = append(opts.Opts, makeSmuxTransportOption(mplex)) - return + res, err := makeSmuxTransportOption(tptConfig) + if err != nil { + return opts, err + } + opts.Opts = append(opts.Opts, res) + return opts, nil } } diff --git a/core/node/libp2p/transport.go b/core/node/libp2p/transport.go index 3994da5c521..c5112e9c0b8 100644 --- a/core/node/libp2p/transport.go +++ b/core/node/libp2p/transport.go @@ -1,29 +1,46 @@ package libp2p import ( - "github.com/libp2p/go-libp2p" + "fmt" + + config "github.com/ipfs/go-ipfs-config" + libp2p "github.com/libp2p/go-libp2p" metrics "github.com/libp2p/go-libp2p-core/metrics" libp2pquic "github.com/libp2p/go-libp2p-quic-transport" - secio "github.com/libp2p/go-libp2p-secio" - tls "github.com/libp2p/go-libp2p-tls" + tcp "github.com/libp2p/go-tcp-transport" + websocket "github.com/libp2p/go-ws-transport" + + "go.uber.org/fx" ) -var DefaultTransports = simpleOpt(libp2p.DefaultTransports) -var QUIC = simpleOpt(libp2p.Transport(libp2pquic.NewTransport)) - -func Security(enabled bool) interface{} { - if !enabled { - return func() (opts Libp2pOpts) { - // TODO: shouldn't this be Errorf to guarantee visibility? - log.Warnf(`Your IPFS node has been configured to run WITHOUT ENCRYPTED CONNECTIONS. - You will not be able to connect to any nodes configured to use encrypted connections`) - opts.Opts = append(opts.Opts, libp2p.NoSecurity) - return opts +func Transports(tptConfig config.Transports) interface{} { + return func(pnet struct { + fx.In + Fprint PNetFingerprint `optional:"true"` + }) (opts Libp2pOpts, err error) { + privateNetworkEnabled := pnet.Fprint != nil + + if tptConfig.Network.TCP.WithDefault(true) { + opts.Opts = append(opts.Opts, libp2p.Transport(tcp.NewTCPTransport)) } - } - return func() (opts Libp2pOpts) { - opts.Opts = append(opts.Opts, libp2p.ChainOptions(libp2p.Security(tls.ID, tls.New), libp2p.Security(secio.ID, secio.New))) - return opts + + if tptConfig.Network.Websocket.WithDefault(true) { + opts.Opts = append(opts.Opts, libp2p.Transport(websocket.New)) + } + + if tptConfig.Network.QUIC.WithDefault(!privateNetworkEnabled) { + if privateNetworkEnabled { + // QUIC was force enabled while the private network was turned on. + // Fail and tell the user. + return opts, fmt.Errorf( + "The QUIC transport does not support private networks. " + + "Please disable Swarm.Transports.Network.QUIC.", + ) + } + opts.Opts = append(opts.Opts, libp2p.Transport(libp2pquic.NewTransport)) + } + + return opts, nil } } diff --git a/core/node/peering.go b/core/node/peering.go new file mode 100644 index 00000000000..b5e7caadc33 --- /dev/null +++ b/core/node/peering.go @@ -0,0 +1,34 @@ +package node + +import ( + "context" + + "github.com/ipfs/go-ipfs/peering" + "github.com/libp2p/go-libp2p-core/host" + "github.com/libp2p/go-libp2p-core/peer" + "go.uber.org/fx" +) + +// Peering constructs the peering service and hooks it into fx's lifetime +// management system. +func Peering(lc fx.Lifecycle, host host.Host) *peering.PeeringService { + ps := peering.NewPeeringService(host) + lc.Append(fx.Hook{ + OnStart: func(context.Context) error { + return ps.Start() + }, + OnStop: func(context.Context) error { + return ps.Stop() + }, + }) + return ps +} + +// PeerWith configures the peering service to peer with the specified peers. +func PeerWith(peers ...peer.AddrInfo) fx.Option { + return fx.Invoke(func(ps *peering.PeeringService) { + for _, ai := range peers { + ps.AddPeer(ai) + } + }) +} diff --git a/docs/RELEASE_ISSUE_TEMPLATE.md b/docs/RELEASE_ISSUE_TEMPLATE.md index 7cdfcfd3433..33fb815d015 100644 --- a/docs/RELEASE_ISSUE_TEMPLATE.md +++ b/docs/RELEASE_ISSUE_TEMPLATE.md @@ -86,7 +86,10 @@ Checklist: - [ ] to [dist.ipfs.io](https://dist.ipfs.io) - [ ] to [npm-go-ipfs](https://github.com/ipfs/npm-go-ipfs) - [ ] to [chocolatey](https://chocolatey.org/packages/ipfs) + - [ ] to [snap](https://snapcraft.io/ipfs) - [ ] to [github](https://github.com/ipfs/go-ipfs/releases) + - [ ] to [arch](https://www.archlinux.org/packages/community/x86_64/go-ipfs/) (flag it out of date) + - [ ] Cut a new ipfs-desktop release - [ ] Publish a Release Blog post (at minimum, a c&p of this release issue with all the highlights, API changes, link to changelog and thank yous) - [ ] Broadcasting (link to blog post) - [ ] Twitter diff --git a/docs/config.md b/docs/config.md index 5513acf092e..d509915d562 100644 --- a/docs/config.md +++ b/docs/config.md @@ -5,7 +5,7 @@ is read once at node instantiation, either for an offline command, or when starting the daemon. Commands that execute on a running daemon do not read the config file at runtime. -#### Profiles +## Profiles Configuration profiles allow to tweak configuration quickly. Profiles can be applied with `--profile` flag to `ipfs init` or with the `ipfs config profile @@ -24,7 +24,7 @@ documented in `ipfs config profile --help`. Use a random port number for swarm. -- `default-datatore` +- `default-datastore` Configures the node to use the default datastore (flatfs). @@ -89,6 +89,46 @@ documented in `ipfs config profile --help`. functionality - performance of content discovery and data fetching may be degraded. +## Types + +This document refers to the standard JSON types (e.g., `null`, `string`, +`number`, etc.), as well as a few custom types, described below. + +### `flag` + +Flags allow enabling and disabling features. However, unlike simple booleans, +they can also be `null` (or omitted) to indicate that the default value should +be chosen. This makes it easier for go-ipfs to change the defaults in the +future unless the user _explicitly_ sets the flag to either `true` (enabled) or +`false` (disabled). Flags have three possible states: + +- `null` or missing (apply the default value). +- `true` (enabled) +- `false` (disabled) + +### `priority` + +Priorities allow specifying the priority of a feature/protocol and disabling the +feature/protocol. Priorities can take one of the following values: + +- `null`/missing (apply the default priority, same as with flags) +- `false` (disabled) +- `1 - 2^63` (priority, lower is preferred) + +### `strings` + +Strings is a special type for conveniently specifying a single string, an array +of strings, or null: + +- `null` +- `"a single string"` +- `["an", "array", "of", "strings"]` + +### `duration` + +Duration is a type for describing lengths of time, using the same format go +does (e.g, `"1d2h4m40.01s"`). + ## Table of Contents - [`Addresses`](#addresses) @@ -117,8 +157,6 @@ documented in `ipfs config profile --help`. - [`Discovery.MDNS`](#discoverymdns) - [`Discovery.MDNS.Enabled`](#discoverymdnsenabled) - [`Discovery.MDNS.Interval`](#discoverymdnsinterval) -- [`Routing`](#routing) - - [`Routing.Type`](#routingtype) - [`Gateway`](#gateway) - [`Gateway.NoFetch`](#gatewaynofetch) - [`Gateway.NoDNSLink`](#gatewaynodnslink) @@ -138,9 +176,16 @@ documented in `ipfs config profile --help`. - [`Mounts.IPFS`](#mountsipfs) - [`Mounts.IPNS`](#mountsipns) - [`Mounts.FuseAllowOther`](#mountsfuseallowother) +- [`Pubsub`](#pubsub) + - [`Pubsub.Router`](#pubsubrouter) + - [`Pubsub.DisableSigning`](#pubsubdisablesigning) + - [`Peering`](#peering) + - [`Peering.Peers`](#peeringpeers) - [`Reprovider`](#reprovider) - [`Reprovider.Interval`](#reproviderinterval) - [`Reprovider.Strategy`](#reproviderstrategy) +- [`Routing`](#routing) + - [`Routing.Type`](#routingtype) - [`Swarm`](#swarm) - [`Swarm.AddrFilters`](#swarmaddrfilters) - [`Swarm.DisableBandwidthMetrics`](#swarmdisablebandwidthmetrics) @@ -153,6 +198,19 @@ documented in `ipfs config profile --help`. - [`Swarm.ConnMgr.LowWater`](#swarmconnmgrlowwater) - [`Swarm.ConnMgr.HighWater`](#swarmconnmgrhighwater) - [`Swarm.ConnMgr.GracePeriod`](#swarmconnmgrgraceperiod) + - [`Swarm.Transports`](#swarmtransports) + - [`Swarm.Transports.Security`](#swarmtransportssecurity) + - [`Swarm.Transports.Security.TLS`](#swarmtransportssecuritytls) + - [`Swarm.Transports.Security.SECIO`](#swarmtransportssecuritysecio) + - [`Swarm.Transports.Security.Noise`](#swarmtransportssecuritynoise) + - [`Swarm.Transports.Multiplexers`](#swarmtransportsmultiplexers) + - [`Swarm.Transports.Multiplexers.Yamux`](#swarmtransportsmultiplexersyamux) + - [`Swarm.Transports.Multiplexers.Mplex`](#swarmtransportsmultiplexersmplex) + - [`Swarm.Transports.Network`](#swarmtransportsnetwork) + - [`Swarm.Transports.Network.TCP`](#swarmtransportsnetworktcp) + - [`Swarm.Transports.Network.QUIC`](#swarmtransportsnetworkquic) + - [`Swarm.Transports.Network.Websocket`](#swarmtransportsnetworkwebsocket) + - [`Swarm.Transports.Network.Relay`](#swarmtransportsnetworkrelay) ## `Addresses` @@ -170,6 +228,8 @@ Supported Transports: Default: `/ip4/127.0.0.1/tcp/5001` +Type: `strings` (multiaddrs) + ### `Addresses.Gateway` Multiaddr or array of multiaddrs describing the address to serve the local @@ -182,6 +242,8 @@ Supported Transports: Default: `/ip4/127.0.0.1/tcp/8080` +Type: `strings` (multiaddrs) + ### `Addresses.Swarm` Array of multiaddrs describing which addresses to listen on for p2p swarm @@ -197,10 +259,14 @@ Default: ```json [ "/ip4/0.0.0.0/tcp/4001", - "/ip6/::/tcp/4001" + "/ip6/::/tcp/4001", + "/ip6/0.0.0.0/udp/4001/quic", + "/ip6/::/udp/4001/quic" ] ``` +Type: `array[string]` (multiaddrs) + ### `Addresses.Announce` If non-empty, this array specifies the swarm addresses to announce to the @@ -208,11 +274,15 @@ network. If empty, the daemon will announce inferred swarm addresses. Default: `[]` +Type: `array[string]` (multiaddrs) + ### `Addresses.NoAnnounce` Array of swarm addresses not to announce to the network. Default: `[]` +Type: `array[string]` (multiaddrs) + ## `API` Contains information used by the API gateway. @@ -228,6 +298,8 @@ Example: Default: `null` +Type: `object[string -> array[string]]` (header names -> array of header values) + ## `AutoNAT` Contains the configuration options for the AutoNAT service. The AutoNAT service @@ -245,6 +317,8 @@ field can take one of two values: Additional modes may be added in the future. +Type: `string` (one of `"enabled"` or `"disabled"`) + ### `AutoNAT.Throttle` When set, this option configure's the AutoNAT services throttling behavior. By @@ -257,18 +331,24 @@ Configures how many AutoNAT requests to service per `AutoNAT.Throttle.Interval`. Default: 30 +Type: `integer` (non-negative, `0` means unlimited) + ### `AutoNAT.Throttle.PeerLimit` Configures how many AutoNAT requests per-peer to service per `AutoNAT.Throttle.Interval`. Default: 3 +Type: `integer` (non-negative, `0` means unlimited) + ### `AutoNAT.Throttle.Interval` Configures the interval for the above limits. Default: 1 Minute +Type: `duration` (when `0`/unset, the default value is used) + ## `Bootstrap` Bootstrap is an array of multiaddrs of trusted nodes to connect to in order to @@ -276,6 +356,8 @@ initiate a connection to the network. Default: The ipfs.io bootstrap nodes +Type: `array[string]` (multiaddrs) + ## `Datastore` Contains information related to the construction and operation of the on-disk @@ -286,7 +368,9 @@ storage system. A soft upper limit for the size of the ipfs repository's datastore. With `StorageGCWatermark`, is used to calculate whether to trigger a gc run (only if `--enable-gc` flag is set). -Default: `10GB` +Default: `"10GB"` + +Type: `string` (size) ### `Datastore.StorageGCWatermark` @@ -296,6 +380,8 @@ option defaults to false currently). Default: `90` +Type: `integer` (0-100%) + ### `Datastore.GCPeriod` A time duration specifying how frequently to run a garbage collection. Only used @@ -303,6 +389,8 @@ if automatic gc is enabled. Default: `1h` +Type: `duration` (an empty string means the default value) + ### `Datastore.HashOnRead` A boolean value. If set to true, all block reads from disk will be hashed and @@ -310,6 +398,8 @@ verified. This will cause increased CPU utilization. Default: `false` +Type: `bool` + ### `Datastore.BloomFilterSize` A number representing the size in bytes of the blockstore's [bloom @@ -326,8 +416,9 @@ we'd want to use 1199120 bytes. As of writing, [7 hash functions](https://github.com/ipfs/go-ipfs-blockstore/blob/547442836ade055cc114b562a3cc193d4e57c884/caching.go#L22) are used, so the constant `k` is 7 in the formula. +Default: `0` (disabled) -Default: `0` +Type: `integer` (non-negative, bytes) ### `Datastore.Spec` @@ -373,6 +464,8 @@ Default: } ``` +Type: `object` + ## `Discovery` Contains options for configuring ipfs node discovery mechanisms. @@ -387,51 +480,15 @@ A boolean value for whether or not mdns should be active. Default: `true` +Type: `bool` + #### `Discovery.MDNS.Interval` A number of seconds to wait between discovery checks. -## `Routing` +Default: `5` -Contains options for content, peer, and IPNS routing mechanisms. - -### `Routing.Type` - -Content routing mode. Can be overridden with daemon `--routing` flag. - -There are two core routing options: "none" and "dht" (default). - -* 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. -* If set to "dht" (or "dhtclient"/"dhtserver"), your node will use the IPFS DHT. - -When the DHT is enabled, it can operate in two modes: client and server. - -* In server mode, your node will query other peers for DHT records, and will - respond to requests from other peers (both requests to store records and - requests to retrieve records). -* In client mode, your node will query the DHT as a client but will not respond - to requests from other peers. This mode is less resource intensive than server - mode. - -When `Routing.Type` is set to `dht`, your node will start as a DHT client, and -switch to a DHT server when and if it determines that it's reachable from the -public internet (e.g., it's not behind a firewall). - -To force a specific DHT 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. - -**Example:** - -```json -{ - "Routing": { - "Type": "dhtclient" - } -} -``` - +Type: `integer` (integer seconds, 0 means the default) ## `Gateway` @@ -444,6 +501,8 @@ and will not fetch files from the network. Default: `false` +Type: `bool` + ### `Gateway.NoDNSLink` A boolean to configure whether DNSLink lookup for value in `Host` HTTP header @@ -452,6 +511,8 @@ record becomes the `/` and respective payload is returned to the client. Default: `false` +Type: `bool` + ### `Gateway.HTTPHeaders` Headers to set on gateway responses. @@ -471,18 +532,24 @@ Default: } ``` +Type: `object[string -> array[string]]` + ### `Gateway.RootRedirect` A url to redirect requests for `/` to. Default: `""` +Type: `string` (url) + ### `Gateway.Writable` A boolean to configure whether the gateway is writeable or not. Default: `false` +Type: `bool` + ### `Gateway.PathPrefixes` Array of acceptable url paths that a client can specify in X-Ipfs-Path-Prefix @@ -498,6 +565,7 @@ Example: We mount `blog.ipfs.io` (a dnslink page) at `ipfs.io/blog`. ```json "Gateway": { "PathPrefixes": ["/blog"], +} ``` **nginx_ipfs.conf** @@ -512,6 +580,7 @@ location /blog/ { Default: `[]` +Type: `array[string]` ### `Gateway.PublicGateways` @@ -528,12 +597,18 @@ Example: "PublicGateways": { "example.com": { "Paths": ["/ipfs", "/ipns"], + } + } + } +} ``` Above enables `http://example.com/ipfs/*` and `http://example.com/ipns/*` but not `http://example.com/api/*` Default: `[]` +Type: `array[string]` + #### `Gateway.PublicGateways: UseSubdomains` A boolean to configure whether the gateway at the hostname provides [Origin isolation](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy) @@ -543,12 +618,14 @@ between content roots. - **Requires whitelist:** make sure respective `Paths` are set. For example, `Paths: ["/ipfs", "/ipns"]` are required for `http://{cid}.ipfs.{hostname}` and `http://{foo}.ipns.{hostname}` to work: ```json - { "Gateway": { "PublicGateways": { - "dweb.link": { - "UseSubdomains": true, - "Paths": ["/ipfs", "/ipns"], + "dweb.link": { + "UseSubdomains": true, + "Paths": ["/ipfs", "/ipns"], + } + } + } ``` - **Backward-compatible:** requests for content paths such as `http://{hostname}/ipfs/{cid}` produce redirect to `http://{cid}.ipfs.{hostname}` - **API:** if `/api` is on the `Paths` whitelist, `http://{hostname}/api/{cmd}` produces redirect to `http://api.{hostname}/api/{cmd}` @@ -556,17 +633,20 @@ between content roots. - `false` - enables [path gateway](https://docs-beta.ipfs.io/how-to/address-ipfs-on-web/#path-gateway) at `http://{hostname}/*` - Example: ```json - { "Gateway": { "PublicGateways": { - "ipfs.io": { - "UseSubdomains": false, - "Paths": ["/ipfs", "/ipns", "/api"], + "ipfs.io": { + "UseSubdomains": false, + "Paths": ["/ipfs", "/ipns", "/api"], + } + } + } ``` Default: `false` +Type: `bool` #### `Gateway.PublicGateways: NoDNSLink` @@ -576,6 +656,8 @@ If `Paths` are defined, they take priority over DNSLink. Default: `false` (DNSLink lookup enabled by default for every defined hostname) +Type: `bool` + #### Implicit defaults of `Gateway.PublicGateways` Default entries for `localhost` hostname and loopback IPs are always present. @@ -614,8 +696,10 @@ Below is a list of the most common public gateway setups. } }' ``` - **Note:** this enables automatic redirects from content paths to subdomains - `http://dweb.link/ipfs/{cid}` → `http://{cid}.ipfs.dweb.link` + **Note I:** this enables automatic redirects from content paths to subdomains: + `http://dweb.link/ipfs/{cid}` → `http://{cid}.ipfs.dweb.link` + **Note II:** if you run go-ipfs behind a reverse proxy that provides TLS, make it adds a `X-Forwarded-Proto: https` HTTP header to ensure users are redirected to `https://`, not `http://`. The NGINX directive is `proxy_set_header X-Forwarded-Proto "https";`.: + `https://dweb.link/ipfs/{cid}` → `https://{cid}.ipfs.dweb.link` * Public [path gateway](https://docs-beta.ipfs.io/how-to/address-ipfs-on-web/#path-gateway) at `http://ipfs.io/ipfs/{cid}` (no Origin separation) ```console @@ -659,23 +743,33 @@ The unique PKI identity label for this configs peer. Set on init and never read, it's merely here for convenience. Ipfs will always generate the peerID from its keypair at runtime. +Type: `string` (peer ID) + ### `Identity.PrivKey` The base64 encoded protobuf describing (and containing) the nodes private key. +Type: `string` (base64 encoded) + ## `Ipns` ### `Ipns.RepublishPeriod` A time duration specifying how frequently to republish ipns records to ensure -they stay fresh on the network. If unset, we default to 4 hours. +they stay fresh on the network. + +Default: 4 hours. + +Type: `interval` or an empty string for the default. ### `Ipns.RecordLifetime` A time duration specifying the value to set on ipns records for their validity lifetime. -If unset, we default to 24 hours. +Default: 24 hours. + +Type: `interval` or an empty string for the default. ### `Ipns.ResolveCacheSize` @@ -684,6 +778,8 @@ will be kept cached until their lifetime is expired. Default: `128` +Type: `integer` (non-negative, 0 means the default) + ## `Mounts` FUSE mount point configuration options. @@ -692,14 +788,109 @@ FUSE mount point configuration options. Mountpoint for `/ipfs/`. +Default: `/ipfs` + +Type: `string` (filesystem path) + ### `Mounts.IPNS` Mountpoint for `/ipns/`. +Default: `/ipns` + +Type: `string` (filesystem path) + ### `Mounts.FuseAllowOther` Sets the FUSE allow other option on the mountpoint. +## `Pubsub` + +Pubsub configures the `ipfs pubsub` subsystem. To use, it must be enabled by +passing the `--enable-pubsub-experiment` flag to the daemon. + +### `Pubsub.Router` + +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 + connected peers. This router is extremely inefficient but _very_ reliable. +* `"gossipsub"` - [gossipsub][] is a more advanced routing algorithm that will + build an overlay mesh from a subset of the links in the network. + +Default: `"gossipsub"` + +Type: `string` (one of `"floodsub"`, `"gossipsub"`, or `""` (apply default)) + +[gossipsub]: https://github.com/libp2p/specs/tree/master/pubsub/gossipsub + +### `Pubsub.DisableSigning` + +Disables message signing and signature verification. Enable this option if +you're operating in a completely trusted network. + +It is _not_ safe to disable signing even if you don't care _who_ sent the +message because spoofed messages can be used to silence real messages by +intentionally re-using the real message's message ID. + +Default: `false` + +Type: `bool` + +### `Peering` + +Configures the peering subsystem. The peering subsystem configures go-ipfs to +connect to, remain connected to, and reconnect to a set of nodes. Nodes should +use this subsystem to create "sticky" links between frequently useful peers to +improve reliability. + +Use-cases: + +* An IPFS gateway connected to an IPFS cluster should peer to ensure that the + gateway can always fetch content from the cluster. +* A dapp may peer embedded go-ipfs nodes with a set of pinning services or + textile cafes/hubs. +* A set of friends may peer to ensure that they can always fetch each other's + content. + +When a node is added to the set of peered nodes, go-ipfs will: + +1. Protect connections to this node from the connection manager. That is, + go-ipfs will never automatically close the connection to this node and + connections to this node will not count towards the connection limit. +2. Connect to this node on startup. +3. Repeatedly try to reconnect to this node if the last connection dies or the + node goes offline. This repeated re-connect logic is governed by a randomized + exponential backoff delay ranging from ~5 seconds to ~10 minutes to avoid + repeatedly reconnect to a node that's offline. + +Peering can be asymmetric or symmetric: + +* When symmetric, the connection will be protected by both nodes and will likely + be vary stable. +* When asymmetric, only one node (the node that configured peering) will protect + the connection and attempt to re-connect to the peered node on disconnect. If + the peered node is under heavy load and/or has a low connection limit, the + connection may flap repeatedly. Be careful when asymmetrically peering to not + overload peers. + +#### `Peering.Peers` + +The set of peers with which to peer. Each entry is of the form: + +```js +{ + "ID": "QmSomePeerID", # The peers ID. + "Addrs": ["/ip4/1.2.3.4/tcp/1234"] # Known addresses for the peer. If none are specified, the DHT will be queried. +} +``` + +Additional fields may be added in the future. + +Default: empty. + +Type: `array[peering]` + ## `Reprovider` ### `Reprovider.Interval` @@ -713,12 +904,63 @@ not being able to discover that you have the objects that you have. If you want to have this disabled and keep the network aware of what you have, you must manually announce your content periodically. +Type: `array[peering]` + ### `Reprovider.Strategy` Tells reprovider what should be announced. Valid strategies are: - - "all" (default) - announce all stored data + - "all" - announce all stored data - "pinned" - only announce pinned data - "roots" - only announce directly pinned keys and root keys of recursive pins + +Default: all + +Type: `string` (or unset for the default) + +## `Routing` + +Contains options for content, peer, and IPNS routing mechanisms. + +### `Routing.Type` + +Content routing mode. Can be overridden with daemon `--routing` flag. + +There are two core routing options: "none" and "dht" (default). + +* 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. +* If set to "dht" (or "dhtclient"/"dhtserver"), your node will use the IPFS DHT. + +When the DHT is enabled, it can operate in two modes: client and server. + +* In server mode, your node will query other peers for DHT records, and will + respond to requests from other peers (both requests to store records and + requests to retrieve records). +* In client mode, your node will query the DHT as a client but will not respond + to requests from other peers. This mode is less resource intensive than server + mode. + +When `Routing.Type` is set to `dht`, your node will start as a DHT client, and +switch to a DHT server when and if it determines that it's reachable from the +public internet (e.g., it's not behind a firewall). + +To force a specific DHT 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. + +**Example:** + +```json +{ + "Routing": { + "Type": "dhtclient" + } +} +``` + +Default: dht + +Type: `string` (or unset for the default) ## `Swarm` @@ -738,6 +980,9 @@ 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. +Default: `[]` + +Type: `array[string]` ### `Swarm.DisableBandwidthMetrics` @@ -745,6 +990,10 @@ A boolean value that when set to true, will cause ipfs to not keep track of bandwidth metrics. Disabling bandwidth metrics can lead to a slight performance improvement, as well as a reduction in memory usage. +Default: `false` + +Type: `bool` + ### `Swarm.DisableNatPortMap` Disable automatic NAT port forwarding. @@ -754,12 +1003,22 @@ up an external port and forward it to the port go-ipfs is running on. When this works (i.e., when your router supports NAT port forwarding), it makes the local go-ipfs node accessible from the public internet. +Default: `false` + +Type: `bool` + ### `Swarm.DisableRelay` +Deprecated: Set `Swarm.Transports.Network.Relay` to `false`. + Disables the p2p-circuit relay transport. This will prevent this node from connecting to nodes behind relays, or accepting connections from nodes behind relays. +Default: `false` + +Type: `bool` + ### `Swarm.EnableRelayHop` Configures this node to act as a relay "hop". A relay "hop" relays traffic for other peers. @@ -768,12 +1027,20 @@ WARNING: Do not enable this option unless you know what you're doing. Other peers will randomly decide to use your node as a relay and consume _all_ available bandwidth. There is _no_ rate-limiting. +Default: `false` + +Type: `bool` + ### `Swarm.EnableAutoRelay` Enables "automatic relay" mode for this node. This option does two _very_ different things based on the `Swarm.EnableRelayHop`. See [#7228](https://github.com/ipfs/go-ipfs/issues/7228) for context. +Default: `false` + +Type: `bool` + #### Mode 1: `EnableRelayHop` is `false` If `Swarm.EnableAutoRelay` is enabled and `Swarm.EnableRelayHop` is disabled, @@ -801,37 +1068,37 @@ Please use [`AutoNAT.ServiceMode`][]. ### `Swarm.ConnMgr` The connection manager determines which and how many connections to keep and can -be configured to keep. +be configured to keep. Go-ipfs currently supports two connection managers: + +* none: never close idle connections. +* basic: the default connection manager. + +Default: basic #### `Swarm.ConnMgr.Type` Sets the type of connection manager to use, options are: `"none"` (no connection management) and `"basic"`. -#### Basic Connection Manager +Default: "basic". -##### `Swarm.ConnMgr.LowWater` +Type: `string` (when unset or `""`, the default connection manager is applied +and all `ConnMgr` fields are ignored). -LowWater is the minimum number of connections to maintain. - -##### `Swarm.ConnMgr.HighWater` - -HighWater is the number of connections that, when exceeded, will trigger a -connection GC operation. - -##### `Swarm.ConnMgr.GracePeriod` +#### Basic Connection Manager -GracePeriod is a time duration that new connections are immune from being closed -by the connection manager. +The basic connection manager uses a "high water", a "low water", and internal +scoring to periodically close connections to free up resources. When a node +using the basic connection manager reaches `HighWater` idle connections, it will +close the least useful ones until it reaches `LowWater` idle connections. -The "basic" connection manager tries to keep between `LowWater` and `HighWater` -connections. It works by: +The connection manager considers a connection idle if: -1. Keeping all connections until `HighWater` connections is reached. -2. Once `HighWater` is reached, it closes connections until `LowWater` is - reached. -3. To prevent thrashing, it never closes connections established within the - `GracePeriod`. +* It has not been explicitly _protected_ by some subsystem. For example, Bitswap + will protect connections to peers from which it is actively downloading data, + the DHT will protect some peers for routing, and the peering subsystem will + protect all "peered" nodes. +* It has existed for longer than the `GracePeriod`. **Example:** @@ -847,3 +1114,197 @@ connections. It works by: } } ``` + +##### `Swarm.ConnMgr.LowWater` + +LowWater is the number of connections that the basic connection manager will +trim down to. + +Default: `600` + +Type: `integer` + +##### `Swarm.ConnMgr.HighWater` + +HighWater is the number of connections that, when exceeded, will trigger a +connection GC operation. Note: protected/recently formed connections don't count +towards this limit. + +Default: `900` + +Type: `integer` + +##### `Swarm.ConnMgr.GracePeriod` + +GracePeriod is a time duration that new connections are immune from being closed +by the connection manager. + +Default: `"20s"` + +Type: `duration` + +### `Swarm.Transports` + +Configuration section for libp2p transports. An empty configuration will apply +the defaults. + +### `Swarm.Transports.Network` + +Configuration section for libp2p _network_ transports. Transports enabled in +this section will be used for dialing. However, to receive connections on these +transports, multiaddrs for these transports must be added to `Addresses.Swarm`. + +Supported transports are: QUIC, TCP, WS, and Relay. + +Each field in this section is a `flag`. + +#### `Swarm.Transports.Network.TCP` + +[TCP](https://en.wikipedia.org/wiki/Transmission_Control_Protocol) is the most +widely used transport by go-ipfs nodes. It doesn't directly support encryption +and/or multiplexing, so libp2p will layer a security & multiplexing transport +over it. + +Default: Enabled + +Type: `flag` + +Listen Addresses: +* /ip4/0.0.0.0/tcp/4001 (default) +* /ip6/::/tcp/4001 (default) + +#### `Swarm.Transports.Network.Websocket` + +[Websocket](https://en.wikipedia.org/wiki/WebSocket) is a transport usually used +to connect to non-browser-based IPFS nodes from browser-based js-ipfs nodes. + +While it's enabled by default for dialing, go-ipfs doesn't listen on this +transport by default. + +Default: Enabled + +Type: `flag` + +Listen Addresses: +* /ip4/0.0.0.0/tcp/4002/ws +* /ip6/::/tcp/4002/ws + +#### `Swarm.Transports.Network.QUIC` + +[QUIC](https://en.wikipedia.org/wiki/QUIC) is a UDP-based transport with +built-in encryption and multiplexing. The primary benefits over TCP are: + +1. It doesn't require a file descriptor per connection, easing the load on the OS. +2. It currently takes 2 round trips to establish a connection (our TCP transport + currently takes 6). + +Default: Enabled + +Type: `flag` + +Listen Addresses: +* /ip4/0.0.0.0/udp/4001/quic (default) +* /ip6/::/udp/4001/quic (default) + +#### `Swarm.Transports.Network.Relay` + +[Libp2p Relay](https://github.com/libp2p/specs/tree/master/relay) proxy +transport that forms connections by hopping between multiple libp2p nodes. This +transport is primarily useful for bypassing firewalls and NATs. + +Default: Enabled + +Type: `flag` + +Listen Addresses: This transport is special. Any node that enables this +transport can receive inbound connections on this transport, without specifying +a listen address. + +### `Swarm.Transports.Security` + +Configuration section for libp2p _security_ transports. Transports enabled in +this section will be used to secure unencrypted connections. + +Security transports are configured with the `priority` type. + +When establishing an _outbound_ connection, go-ipfs will try each security +transport in priority order (lower first), until it finds a protocol that the +receiver supports. When establishing an _inbound_ connection, go-ipfs will let +the initiator choose the protocol, but will refuse to use any of the disabled +transports. + +Supported transports are: TLS (priority 100), SECIO (priority 200), Noise +(priority 300). + +No default priority will ever be less than 100. + +#### `Swarm.Transports.Security.TLS` + +[TLS](https://github.com/libp2p/specs/tree/master/tls) (1.3) is the default +security transport as of go-ipfs 0.5.0. It's also the most scrutinized and +trusted security transport. + +Default: `100` + +Type: `priority` + +#### `Swarm.Transports.Security.SECIO` + +[SECIO](https://github.com/libp2p/specs/tree/master/secio) is the most widely +supported IPFS & libp2p security transport. However, it is currently being +phased out in favor of more popular and better vetted protocols like TLS and +Noise. + +Default: `200` + +Type: `priority` + +#### `Swarm.Transports.Security.Noise` + +[Noise](https://github.com/libp2p/specs/tree/master/noise) is slated to replace +TLS as the cross-platform, default libp2p protocol due to ease of +implementation. It is currently enabled by default but with low priority as it's +not yet widely supported. + +Default: `300` + +Type: `priority` + +### `Swarm.Transports.Multiplexers` + +Configuration section for libp2p _multiplexer_ transports. Transports enabled in +this section will be used to multiplex duplex connections. + +Multiplexer transports are secured the same way security transports are, with +the `priority` type. Like with security transports, the initiator gets their +first choice. + +Supported transports are: Yamux (priority 100) and Mplex (priority 200) + +No default priority will ever be less than 100. + +### `Swarm.Transports.Multiplexers.Yamux` + +Yamux is the default multiplexer used when communicating between go-ipfs nodes. + +Default: `100` + +Type: `priority` + +### `Swarm.Transports.Multiplexers.Mplex` + +Mplex is the default multiplexer used when communicating between go-ipfs and all +other IPFS and libp2p implementations. Unlike Yamux: + +* Mplex is a simpler protocol. +* Mplex is more efficient. +* Mplex does not have built-in keepalives. +* Mplex does not support backpressure. Unfortunately, this means that, if a + single stream to a peer gets backed up for a period of time, the mplex + transport will kill the stream to allow the others to proceed. On the other + hand, the lack of backpressure means mplex can be significantly faster on some + high-latency connections. + +Default: `200` + +Type: `priority` diff --git a/docs/environment-variables.md b/docs/environment-variables.md index b2338ae3fc9..7f7d0f53bd1 100644 --- a/docs/environment-variables.md +++ b/docs/environment-variables.md @@ -98,6 +98,8 @@ $ ipfs resolve -r /ipns/dnslink-test2.example.com ## `LIBP2P_MUX_PREFS` +Deprecated: Use the `Swarm.Transports.Multiplexers` config field. + Tells go-ipfs which multiplexers to use in which order. Default: "/yamux/1.0.0 /mplex/6.7.0" diff --git a/docs/examples/go-ipfs-as-a-library/go.mod b/docs/examples/go-ipfs-as-a-library/go.mod new file mode 100644 index 00000000000..529e3504cc0 --- /dev/null +++ b/docs/examples/go-ipfs-as-a-library/go.mod @@ -0,0 +1,13 @@ +module github.com/ipfs/go-ipfs/examples/go-ipfs-as-a-library + +go 1.14 + +require ( + github.com/ipfs/go-ipfs v0.5.0 + github.com/ipfs/go-ipfs-config v0.5.3 + github.com/ipfs/go-ipfs-files v0.0.8 + github.com/ipfs/interface-go-ipfs-core v0.2.7 + github.com/libp2p/go-libp2p-core v0.5.2 + github.com/libp2p/go-libp2p-peerstore v0.2.3 + github.com/multiformats/go-multiaddr v0.2.1 +) diff --git a/docs/examples/go-ipfs-as-a-library/go.sum b/docs/examples/go-ipfs-as-a-library/go.sum new file mode 100644 index 00000000000..580c63534af --- /dev/null +++ b/docs/examples/go-ipfs-as-a-library/go.sum @@ -0,0 +1,1094 @@ +bazil.org/fuse v0.0.0-20200117225306-7b5117fecadc h1:utDghgcjE8u+EBjHOgYT+dJPcnDF05KqWMBcjuJy510= +bazil.org/fuse v0.0.0-20200117225306-7b5117fecadc/go.mod h1:FbcW6z/2VytnFDhZfumh8Ss8zxHE6qpMP5sHTRe0EaM= +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.31.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +cloud.google.com/go v0.37.0/go.mod h1:TS1dMSSfndXH133OKGwekG838Om/cQT0BUHV3HcBgoo= +dmitri.shuralyov.com/app/changes v0.0.0-20180602232624-0a106ad413e3/go.mod h1:Yl+fi1br7+Rr3LqpNJf1/uxUdtRUV+Tnj0o93V2B9MU= +dmitri.shuralyov.com/html/belt v0.0.0-20180602232347-f7d459c86be0/go.mod h1:JLBrvjyP0v+ecvNYvCpyZgu5/xkfAUhi6wJj28eUfSU= +dmitri.shuralyov.com/service/change v0.0.0-20181023043359-a85b471d5412/go.mod h1:a1inKt/atXimZ4Mv927x+r7UpyzRUf4emIoiiSC2TN4= +dmitri.shuralyov.com/state v0.0.0-20180228185332-28bcc343414c/go.mod h1:0PRwlb0D6DFvNNtx+9ybjezNCa8XF0xaYcETyp6rHWU= +git.apache.org/thrift.git v0.0.0-20180902110319-2566ecd5d999/go.mod h1:fPE2ZNJGynbRyZ4dJvy6G277gSllfV2HJqblrnkyeyg= +github.com/AndreasBriese/bbloom v0.0.0-20180913140656-343706a395b7/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8= +github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8= +github.com/AndreasBriese/bbloom v0.0.0-20190825152654-46b345b51c96 h1:cTp8I5+VIoKjsnZuH8vjyaysT/ses3EvZeaV/1UkF2M= +github.com/AndreasBriese/bbloom v0.0.0-20190825152654-46b345b51c96/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/Kubuxu/go-os-helper v0.0.1/go.mod h1:N8B+I7vPCT80IcP58r50u4+gEEcsZETFUpAzWW2ep1Y= +github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= +github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= +github.com/Stebalien/go-bitfield v0.0.0-20180330043415-076a62f9ce6e/go.mod h1:3oM7gXIttpYDAJXpVNnSCiUMYBLIZ6cb1t+Ip982MRo= +github.com/Stebalien/go-bitfield v0.0.1/go.mod h1:GNjFpasyUVkHMsfEOk8EFLJ9syQ6SI+XWrX9Wf2XH0s= +github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII= +github.com/alangpierce/go-forceexport v0.0.0-20160317203124-8f1d6941cd75 h1:3ILjVyslFbc4jl1w5TWuvvslFD/nDfR2H8tVaMVLrEY= +github.com/alangpierce/go-forceexport v0.0.0-20160317203124-8f1d6941cd75/go.mod h1:uAXEEpARkRhCZfEvy/y0Jcc888f9tHCc1W7/UeEtreE= +github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= +github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= +github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= +github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= +github.com/alexbrainman/goissue34681 v0.0.0-20191006012335-3fc7a47baff5 h1:iW0a5ljuFxkLGPNem5Ui+KBjFJzKg4Fv2fnxe4dvzpM= +github.com/alexbrainman/goissue34681 v0.0.0-20191006012335-3fc7a47baff5/go.mod h1:Y2QMoi1vgtOIfc+6DhrMOGkLoGzqSV2rKp4Sm+opsyA= +github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c= +github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= +github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= +github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= +github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= +github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= +github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g= +github.com/bren2010/proquint v0.0.0-20160323162903-38337c27106d/go.mod h1:Jbj8eKecMNwf0KFI75skSUZqMB4UCRcndUScVBTWyUI= +github.com/btcsuite/btcd v0.0.0-20190213025234-306aecffea32/go.mod h1:DrZx5ec/dmnfpw9KyYoQyYo7d0KEvTkk/5M/vbZjAr8= +github.com/btcsuite/btcd v0.0.0-20190523000118-16327141da8c/go.mod h1:3J08xEfcugPacsc34/LKRU2yO7YmuT8yt28J8k2+rrI= +github.com/btcsuite/btcd v0.0.0-20190605094302-a0d1e3e36d50/go.mod h1:3J08xEfcugPacsc34/LKRU2yO7YmuT8yt28J8k2+rrI= +github.com/btcsuite/btcd v0.0.0-20190629003639-c26ffa870fd8/go.mod h1:3J08xEfcugPacsc34/LKRU2yO7YmuT8yt28J8k2+rrI= +github.com/btcsuite/btcd v0.0.0-20190824003749-130ea5bddde3/go.mod h1:3J08xEfcugPacsc34/LKRU2yO7YmuT8yt28J8k2+rrI= +github.com/btcsuite/btcd v0.20.1-beta h1:Ik4hyJqN8Jfyv3S4AGBOmyouMsYE3EdYODkMbQjwPGw= +github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ= +github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA= +github.com/btcsuite/btcutil v0.0.0-20190207003914-4c204d697803/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= +github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg= +github.com/btcsuite/go-socks v0.0.0-20170105172521-4720035b7bfd/go.mod h1:HHNXQzUsZCxOoE+CPiyCTO6x34Zs86zZUiwtpXoGdtg= +github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVaaLLH7j4eDXPRvw78tMflu7Ie2bzYOH4Y8rRKBY= +github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc= +github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY= +github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs= +github.com/buger/jsonparser v0.0.0-20181115193947-bf1c66bbce23/go.mod h1:bbYlZJ7hK1yFx9hf58LP0zeX7UjIGs20ufpu3evjr+s= +github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4= +github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM= +github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko= +github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= +github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= +github.com/cheekybits/genny v1.0.0/go.mod h1:+tQajlRqAUrPI7DOSpB0XAqZYtQakVtB7wXkRAgjxjQ= +github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= +github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk= +github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= +github.com/coreos/go-semver v0.2.1-0.20180108230905-e214231b295a/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= +github.com/coreos/go-semver v0.3.0 h1:wkHLiw0WNATZnSG7epLsujiMCgPAc9xhjJ4tgnAxmfM= +github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= +github.com/coreos/go-systemd v0.0.0-20181012123002-c6f51f82210d/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= +github.com/coreos/go-systemd/v22 v22.0.0/go.mod h1:xO0FLkIi5MaZafQlIrOotqXZ90ih+1atmu1JpKERPPk= +github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE= +github.com/crackcomm/go-gitignore v0.0.0-20170627025303-887ab5e44cc3 h1:HVTnpeuvF6Owjd5mniCL8DEXo7uYXdQEmOP4FJbV5tg= +github.com/crackcomm/go-gitignore v0.0.0-20170627025303-887ab5e44cc3/go.mod h1:p1d6YEZWvFzEh4KLyvBcVSnrfNDDvK2zfK/4x2v/4pE= +github.com/cskr/pubsub v1.0.2/go.mod h1:/8MzYXk/NJAz782G8RPkFzXTZVu63VotefPnR9TIRis= +github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davidlazar/go-crypto v0.0.0-20170701192655-dcfb0a7ac018/go.mod h1:rQYf4tfk5sSwFsnDg3qYaBxSjsD9S8+59vW0dKUgme4= +github.com/dgraph-io/badger v1.5.5-0.20190226225317-8115aed38f8f/go.mod h1:VZxzAIRPHRVNRKRo6AXrX9BJegn6il06VMTZVJYCIjQ= +github.com/dgraph-io/badger v1.6.0-rc1/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4= +github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4= +github.com/dgraph-io/badger v1.6.1 h1:w9pSFNSdq/JPM1N12Fz/F/bzo993Is1W+Q7HjPzi7yg= +github.com/dgraph-io/badger v1.6.1/go.mod h1:FRmFw3uxvcpa8zG3Rxs0th+hCLIuaQg8HlNV5bjgnuU= +github.com/dgraph-io/ristretto v0.0.2 h1:a5WaUrDa0qm0YrAAS1tUykT5El3kt62KNZZeMxQn3po= +github.com/dgraph-io/ristretto v0.0.2/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E= +github.com/dgryski/go-farm v0.0.0-20190104051053-3adb47b1fb0f/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= +github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= +github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= +github.com/elgris/jsondiff v0.0.0-20160530203242-765b5c24c302/go.mod h1:qBlWZqWeVx9BjvqBsnC/8RUlAYpIFmPvgROcw0n1scE= +github.com/facebookgo/atomicfile v0.0.0-20151019160806-2de1f203e7d5/go.mod h1:JpoxHjuQauoxiFMl1ie8Xc/7TfLuMZ5eOCONd1sUBHg= +github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= +github.com/fd/go-nat v1.0.0/go.mod h1:BTBu/CKvMmOMUPkKVef1pngt2WFH/lg7E6yQnulfp6E= +github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc= +github.com/francoispqt/gojay v1.2.13 h1:d2m3sFjloqoIUQU3TsHBgj6qg/BVGlTBeHDUmyJnXKk= +github.com/francoispqt/gojay v1.2.13/go.mod h1:ehT5mTG4ua4581f1++1WLG0vPdaA9HaiDsoyrBGkyDY= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= +github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0= +github.com/go-bindata/go-bindata/v3 v3.1.3/go.mod h1:1/zrpXsLD8YDIbhZRqXzm1Ghc7NhEvIN9+Z6R5/xH4I= +github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98= +github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q= +github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= +github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= +github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= +github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= +github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= +github.com/godbus/dbus/v5 v5.0.3/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= +github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= +github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= +github.com/gogo/protobuf v1.3.0/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= +github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.4.0 h1:Rd1kQnQu0Hq3qvJppYSG0HtP+f5LPPUiDswTLiEegLg= +github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.0/go.mod h1:Qd/q+1AKNOZr9uGQzbzCmRO6sUih6GTPZv6a1/R87v0= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs= +github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= +github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4= +github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ= +github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck= +github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= +github.com/google/gopacket v1.1.17 h1:rMrlX2ZY2UbvT+sdz3+6J+pp2z+msCq9MxTU6ymxbBY= +github.com/google/gopacket v1.1.17/go.mod h1:UdDNZ1OO62aGYVnPhxT1U6aI7ukYtA/kB8vaU0diBUM= +github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= +github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY= +github.com/googleapis/gax-go/v2 v2.0.3/go.mod h1:LLvjysVCY1JZeum8Z6l8qUty8fiNwE08qbEPm1M08qg= +github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= +github.com/gopherjs/gopherjs v0.0.0-20190430165422-3e4dfb77656c h1:7lF+Vz0LqiRidnzC1Oq86fpX1q/iEv2KJdrCtttYjT4= +github.com/gopherjs/gopherjs v0.0.0-20190430165422-3e4dfb77656c/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= +github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= +github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= +github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= +github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA= +github.com/grpc-ecosystem/grpc-gateway v1.5.0/go.mod h1:RSKVYQBd5MCa4OVpNdGskqpgL2+G+NZTnrVHpWWfpdw= +github.com/gxed/hashland/keccakpg v0.0.1/go.mod h1:kRzw3HkwxFU1mpmPP8v1WyQzwdGfmKFJ6tItnhQ67kU= +github.com/gxed/hashland/murmur3 v0.0.1/go.mod h1:KjXop02n4/ckmZSnY2+HKcLud/tcmvhST0bie/0lS48= +github.com/gxed/pubsub v0.0.0-20180201040156-26ebdf44f824/go.mod h1:OiEWyHgK+CWrmOlVquHaIK1vhpUJydC9m0Je6mhaiNE= +github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA= +github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= +github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= +github.com/hashicorp/go-multierror v1.1.0 h1:B9UzwGQJehnUY1yNrnwREHc3fGbC2xefo8g4TbElacI= +github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA= +github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= +github.com/hashicorp/golang-lru v0.5.3/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= +github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc= +github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/huin/goupnp v0.0.0-20180415215157-1395d1447324/go.mod h1:MZ2ZmwcBpvOoJ22IJsc7va19ZwoheaBk43rKg12SKag= +github.com/huin/goupnp v1.0.0 h1:wg75sLpL6DZqwHQN6E1Cfk6mtfzS45z8OV+ic+DtHRo= +github.com/huin/goupnp v1.0.0/go.mod h1:n9v9KO1tAxYH82qOn+UTIFQDmx5n1Zxd/ClZDMX7Bnc= +github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o= +github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= +github.com/ipfs/bbloom v0.0.1/go.mod h1:oqo8CVWsJFMOZqTglBG4wydCE4IQA/G2/SEofB0rjUI= +github.com/ipfs/bbloom v0.0.4 h1:Gi+8EGJ2y5qiD5FbsbpX/TMNcJw8gSqr7eyjHa4Fhvs= +github.com/ipfs/bbloom v0.0.4/go.mod h1:cS9YprKXpoZ9lT0n/Mw/a6/aFV6DTjTLYHeA+gyqMG0= +github.com/ipfs/go-bitswap v0.0.3/go.mod h1:jadAZYsP/tcRMl47ZhFxhaNuDQoXawT8iHMg+iFoQbg= +github.com/ipfs/go-bitswap v0.0.9/go.mod h1:kAPf5qgn2W2DrgAcscZ3HrM9qh4pH+X8Fkk3UPrwvis= +github.com/ipfs/go-bitswap v0.1.0/go.mod h1:FFJEf18E9izuCqUtHxbWEvq+reg7o4CW5wSAE1wsxj0= +github.com/ipfs/go-bitswap v0.1.2/go.mod h1:qxSWS4NXGs7jQ6zQvoPY3+NmOfHHG47mhkiLzBpJQIs= +github.com/ipfs/go-bitswap v0.1.3/go.mod h1:YEQlFy0kkxops5Vy+OxWdRSEZIoS7I7KDIwoa5Chkps= +github.com/ipfs/go-bitswap v0.1.8/go.mod h1:TOWoxllhccevbWFUR2N7B1MTSVVge1s6XSMiCSA4MzM= +github.com/ipfs/go-bitswap v0.2.9 h1:23xzQ5kWx9F3Q4PrBS9nbPwMsxdWHXeD9nZX1/ozTlI= +github.com/ipfs/go-bitswap v0.2.9/go.mod h1:2Yjog0GMdH8+AsxkE0DI9D2mANaUTxbVVav0pPoZoug= +github.com/ipfs/go-bitswap v0.2.13 h1:R8mUGpY0vwHljlnBeDE9PdR3DKKiPKevAMkq9qB8cyA= +github.com/ipfs/go-bitswap v0.2.13/go.mod h1:SDXpLeKZagyVVc8/z7sGtmM/lz8lyAmSzrUx3Ge3GXw= +github.com/ipfs/go-block-format v0.0.1/go.mod h1:DK/YYcsSUIVAFNwo/KZCdIIbpN0ROH/baNLgayt4pFc= +github.com/ipfs/go-block-format v0.0.2/go.mod h1:AWR46JfpcObNfg3ok2JHDUfdiHRgWhJgCQF+KIgOPJY= +github.com/ipfs/go-blockservice v0.0.3/go.mod h1:/NNihwTi6V2Yr6g8wBI+BSwPuURpBRMtYNGrlxZ8KuI= +github.com/ipfs/go-blockservice v0.0.7/go.mod h1:EOfb9k/Y878ZTRY/CH0x5+ATtaipfbRhbvNSdgc/7So= +github.com/ipfs/go-blockservice v0.1.0/go.mod h1:hzmMScl1kXHg3M2BjTymbVPjv627N7sYcvYaKbop39M= +github.com/ipfs/go-blockservice v0.1.1/go.mod h1:t+411r7psEUhLueM8C7aPA7cxCclv4O3VsUVxt9kz2I= +github.com/ipfs/go-blockservice v0.1.2/go.mod h1:t+411r7psEUhLueM8C7aPA7cxCclv4O3VsUVxt9kz2I= +github.com/ipfs/go-blockservice v0.1.3 h1:9XgsPMwwWJSC9uVr2pMDsW2qFTBSkxpGMhmna8mIjPM= +github.com/ipfs/go-blockservice v0.1.3/go.mod h1:OTZhFpkgY48kNzbgyvcexW9cHrpjBYIjSR0KoDOFOLU= +github.com/ipfs/go-cid v0.0.1/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM= +github.com/ipfs/go-cid v0.0.2/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM= +github.com/ipfs/go-cid v0.0.3/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM= +github.com/ipfs/go-cid v0.0.4/go.mod h1:4LLaPOQwmk5z9LBgQnpkivrx8BJjUyGwTXCd5Xfj6+M= +github.com/ipfs/go-cid v0.0.5 h1:o0Ix8e/ql7Zb5UVUJEUfjsWCIY8t48++9lR8qi6oiJU= +github.com/ipfs/go-cid v0.0.5/go.mod h1:plgt+Y5MnOey4vO4UlUazGqdbEXuFYitED67FexhXog= +github.com/ipfs/go-cidutil v0.0.2/go.mod h1:ewllrvrxG6AMYStla3GD7Cqn+XYSLqjK0vc+086tB6s= +github.com/ipfs/go-datastore v0.0.1/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE= +github.com/ipfs/go-datastore v0.0.5/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE= +github.com/ipfs/go-datastore v0.1.0/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE= +github.com/ipfs/go-datastore v0.1.1/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw= +github.com/ipfs/go-datastore v0.3.0/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw= +github.com/ipfs/go-datastore v0.3.1/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw= +github.com/ipfs/go-datastore v0.4.0/go.mod h1:SX/xMIKoCszPqp+z9JhPYCmoOoXTvaa13XEbGtsFUhA= +github.com/ipfs/go-datastore v0.4.1/go.mod h1:SX/xMIKoCszPqp+z9JhPYCmoOoXTvaa13XEbGtsFUhA= +github.com/ipfs/go-datastore v0.4.4 h1:rjvQ9+muFaJ+QZ7dN5B1MSDNQ0JVZKkkES/rMZmA8X8= +github.com/ipfs/go-datastore v0.4.4/go.mod h1:SX/xMIKoCszPqp+z9JhPYCmoOoXTvaa13XEbGtsFUhA= +github.com/ipfs/go-detect-race v0.0.1 h1:qX/xay2W3E4Q1U7d9lNs1sU9nvguX0a7319XbyQ6cOk= +github.com/ipfs/go-detect-race v0.0.1/go.mod h1:8BNT7shDZPo99Q74BpGMK+4D8Mn4j46UU0LZ723meps= +github.com/ipfs/go-ds-badger v0.0.2/go.mod h1:Y3QpeSFWQf6MopLTiZD+VT6IC1yZqaGmjvRcKeSGij8= +github.com/ipfs/go-ds-badger v0.0.5/go.mod h1:g5AuuCGmr7efyzQhLL8MzwqcauPojGPUaHzfGTzuE3s= +github.com/ipfs/go-ds-badger v0.0.7/go.mod h1:qt0/fWzZDoPW6jpQeqUjR5kBfhDNB65jd9YlmAvpQBk= +github.com/ipfs/go-ds-badger v0.2.1/go.mod h1:Tx7l3aTph3FMFrRS838dcSJh+jjA7cX9DrGVwx/NOwE= +github.com/ipfs/go-ds-badger v0.2.3/go.mod h1:pEYw0rgg3FIrywKKnL+Snr+w/LjJZVMTBRn4FS6UHUk= +github.com/ipfs/go-ds-badger v0.2.4 h1:UPGB0y7luFHk+mY/tUZrif/272M8o+hFsW+avLUeWrM= +github.com/ipfs/go-ds-badger v0.2.4/go.mod h1:pEYw0rgg3FIrywKKnL+Snr+w/LjJZVMTBRn4FS6UHUk= +github.com/ipfs/go-ds-flatfs v0.4.3 h1:7M8/xpLkJhFJYaLumo2RRgt/cOehetutGW5zigTa5qY= +github.com/ipfs/go-ds-flatfs v0.4.3/go.mod h1:e4TesLyZoA8k1gV/yCuBTnt2PJtypn4XUlB5n8KQMZY= +github.com/ipfs/go-ds-flatfs v0.4.4 h1:DmGZ4qOYQLNgu8Mltuz1DtUHpm+BjWMcVN3F3H3VJzQ= +github.com/ipfs/go-ds-flatfs v0.4.4/go.mod h1:e4TesLyZoA8k1gV/yCuBTnt2PJtypn4XUlB5n8KQMZY= +github.com/ipfs/go-ds-leveldb v0.0.1/go.mod h1:feO8V3kubwsEF22n0YRQCffeb79OOYIykR4L04tMOYc= +github.com/ipfs/go-ds-leveldb v0.1.0/go.mod h1:hqAW8y4bwX5LWcCtku2rFNX3vjDZCy5LZCg+cSZvYb8= +github.com/ipfs/go-ds-leveldb v0.4.1/go.mod h1:jpbku/YqBSsBc1qgME8BkWS4AxzF2cEu1Ii2r79Hh9s= +github.com/ipfs/go-ds-leveldb v0.4.2 h1:QmQoAJ9WkPMUfBLnu1sBVy0xWWlJPg0m4kRAiJL9iaw= +github.com/ipfs/go-ds-leveldb v0.4.2/go.mod h1:jpbku/YqBSsBc1qgME8BkWS4AxzF2cEu1Ii2r79Hh9s= +github.com/ipfs/go-ds-measure v0.1.0 h1:vE4TyY4aeLeVgnnPBC5QzKIjKrqzha0NCujTfgvVbVQ= +github.com/ipfs/go-ds-measure v0.1.0/go.mod h1:1nDiFrhLlwArTME1Ees2XaBOl49OoCgd2A3f8EchMSY= +github.com/ipfs/go-filestore v0.0.3 h1:MhZ1jT5K3NewZwim6rS/akcJLm1xM+r6nz6foeB9EwE= +github.com/ipfs/go-filestore v0.0.3/go.mod h1:dvXRykFzyyXN2CdNlRGzDAkXMDPyI+D7JE066SiKLSE= +github.com/ipfs/go-fs-lock v0.0.4 h1:VhlO2E7awjMxkj6a4nCsrPScRFvEPZxhULtbYdJNZhQ= +github.com/ipfs/go-fs-lock v0.0.4/go.mod h1:SUaaFT1boYZewW+QBw5FZjcDbxkZIWgNdYb1ab93zaY= +github.com/ipfs/go-graphsync v0.0.5 h1:5U9iC58JgYfUSZI55oRXe22Cj6Ln0Xjd5VF4Eoo3foc= +github.com/ipfs/go-graphsync v0.0.5/go.mod h1:SGKa4rVgCCz3KDNqe38wLEDYFa/PUF6w/ertGSQk33I= +github.com/ipfs/go-ipfs v0.5.0-rc1.0.20200411010526-5ecf44a88217 h1:AeaHOd6Gad5PLwKQaK1kMJjs7CHy4ycjWnOWI3TSvdY= +github.com/ipfs/go-ipfs v0.5.0-rc1.0.20200411010526-5ecf44a88217/go.mod h1:Pp9wv2HZkA8vs7zsrYf0RG/im+RLt7X2PyVm/yJuVI4= +github.com/ipfs/go-ipfs v0.5.0 h1:co2Gt86RNvDP7s6ZENCipDxvHLpraMlCdfkQ/zQxRI0= +github.com/ipfs/go-ipfs v0.5.0/go.mod h1:nRbNQQDeXhKo14irTZ0K55rAiViwoml/7dvfqZrjrVI= +github.com/ipfs/go-ipfs-blockstore v0.0.1/go.mod h1:d3WClOmRQKFnJ0Jz/jj/zmksX0ma1gROTlovZKBmN08= +github.com/ipfs/go-ipfs-blockstore v0.1.0/go.mod h1:5aD0AvHPi7mZc6Ci1WCAhiBQu2IsfTduLl+422H6Rqw= +github.com/ipfs/go-ipfs-blockstore v0.1.4 h1:2SGI6U1B44aODevza8Rde3+dY30Pb+lbcObe1LETxOQ= +github.com/ipfs/go-ipfs-blockstore v0.1.4/go.mod h1:Jxm3XMVjh6R17WvxFEiyKBLUGr86HgIYJW/D/MwqeYQ= +github.com/ipfs/go-ipfs-blocksutil v0.0.1/go.mod h1:Yq4M86uIOmxmGPUHv/uI7uKqZNtLb449gwKqXjIsnRk= +github.com/ipfs/go-ipfs-chunker v0.0.1/go.mod h1:tWewYK0we3+rMbOh7pPFGDyypCtvGcBFymgY4rSDLAw= +github.com/ipfs/go-ipfs-chunker v0.0.5 h1:ojCf7HV/m+uS2vhUGWcogIIxiO5ubl5O57Q7NapWLY8= +github.com/ipfs/go-ipfs-chunker v0.0.5/go.mod h1:jhgdF8vxRHycr00k13FM8Y0E+6BoalYeobXmUyTreP8= +github.com/ipfs/go-ipfs-cmds v0.2.2 h1:F2pro/Q3ifRUsdxEKIS8cg8lO4R6WiwAyERiaG8I9no= +github.com/ipfs/go-ipfs-cmds v0.2.2/go.mod h1:kqlUrp6m2ceoaJe40cXpADCi5aS6NKRn0NIeuLp5CeM= +github.com/ipfs/go-ipfs-config v0.4.0 h1:MOXdj8EYQG55v1y+5e1QcctDKPEGobdwnXaDVa0/cc0= +github.com/ipfs/go-ipfs-config v0.4.0/go.mod h1:nSLCFtlaL+2rbl3F+9D4gQZQbT1LjRKx7TJg/IHz6oM= +github.com/ipfs/go-ipfs-config v0.5.3 h1:3GpI/xR9FoJNTjU6YvCMRbYyEi0dBVY5UtlUTcNRlSA= +github.com/ipfs/go-ipfs-config v0.5.3/go.mod h1:nSLCFtlaL+2rbl3F+9D4gQZQbT1LjRKx7TJg/IHz6oM= +github.com/ipfs/go-ipfs-delay v0.0.0-20181109222059-70721b86a9a8/go.mod h1:8SP1YXK1M1kXuc4KJZINY3TQQ03J2rwBG9QfXmbRPrw= +github.com/ipfs/go-ipfs-delay v0.0.1/go.mod h1:8SP1YXK1M1kXuc4KJZINY3TQQ03J2rwBG9QfXmbRPrw= +github.com/ipfs/go-ipfs-ds-help v0.0.1/go.mod h1:gtP9xRaZXqIQRh1HRpp595KbBEdgqWFxefeVKOV8sxo= +github.com/ipfs/go-ipfs-ds-help v0.1.1 h1:IW/bXGeaAZV2VH0Kuok+Ohva/zHkHmeLFBxC1k7mNPc= +github.com/ipfs/go-ipfs-ds-help v0.1.1/go.mod h1:SbBafGJuGsPI/QL3j9Fc5YPLeAu+SzOkI0gFwAg+mOs= +github.com/ipfs/go-ipfs-exchange-interface v0.0.1/go.mod h1:c8MwfHjtQjPoDyiy9cFquVtVHkO9b9Ob3FG91qJnWCM= +github.com/ipfs/go-ipfs-exchange-offline v0.0.1/go.mod h1:WhHSFCVYX36H/anEKQboAzpUws3x7UeEGkzQc3iNkM0= +github.com/ipfs/go-ipfs-files v0.0.2/go.mod h1:INEFm0LL2LWXBhNJ2PMIIb2w45hpXgPjNoE7yA8Y1d4= +github.com/ipfs/go-ipfs-files v0.0.3/go.mod h1:INEFm0LL2LWXBhNJ2PMIIb2w45hpXgPjNoE7yA8Y1d4= +github.com/ipfs/go-ipfs-files v0.0.4/go.mod h1:INEFm0LL2LWXBhNJ2PMIIb2w45hpXgPjNoE7yA8Y1d4= +github.com/ipfs/go-ipfs-files v0.0.8 h1:8o0oFJkJ8UkO/ABl8T6ac6tKF3+NIpj67aAB6ZpusRg= +github.com/ipfs/go-ipfs-files v0.0.8/go.mod h1:wiN/jSG8FKyk7N0WyctKSvq3ljIa2NNTiZB55kpTdOs= +github.com/ipfs/go-ipfs-flags v0.0.1/go.mod h1:RnXBb9WV53GSfTrSDVK61NLTFKvWc60n+K9EgCDh+rA= +github.com/ipfs/go-ipfs-pinner v0.0.4 h1:EmxhS3vDsCK/rZrsgxX0Le9m2drBcGlUd7ah/VyFYVE= +github.com/ipfs/go-ipfs-pinner v0.0.4/go.mod h1:s4kFZWLWGDudN8Jyd/GTpt222A12C2snA2+OTdy/7p8= +github.com/ipfs/go-ipfs-posinfo v0.0.1/go.mod h1:SwyeVP+jCwiDu0C313l/8jg6ZxM0qqtlt2a0vILTc1A= +github.com/ipfs/go-ipfs-pq v0.0.1/go.mod h1:LWIqQpqfRG3fNc5XsnIhz/wQ2XXGyugQwls7BgUmUfY= +github.com/ipfs/go-ipfs-pq v0.0.2 h1:e1vOOW6MuOwG2lqxcLA+wEn93i/9laCY8sXAw76jFOY= +github.com/ipfs/go-ipfs-pq v0.0.2/go.mod h1:LWIqQpqfRG3fNc5XsnIhz/wQ2XXGyugQwls7BgUmUfY= +github.com/ipfs/go-ipfs-provider v0.4.2 h1:FIsBFXKVo8ZXP8XNVnjhZWPjMRLFJeV07BSNVDpJXVY= +github.com/ipfs/go-ipfs-provider v0.4.2/go.mod h1:rcQBVqfblDQRk5LaCtf2uxuKxMJxvKmF5pLS0pO4au4= +github.com/ipfs/go-ipfs-provider v0.4.3 h1:k54OHXZcFBkhL6l3GnPS9PfpaLeLqZjVASG1bgfBdfQ= +github.com/ipfs/go-ipfs-provider v0.4.3/go.mod h1:rcQBVqfblDQRk5LaCtf2uxuKxMJxvKmF5pLS0pO4au4= +github.com/ipfs/go-ipfs-routing v0.0.1/go.mod h1:k76lf20iKFxQTjcJokbPM9iBXVXVZhcOwc360N4nuKs= +github.com/ipfs/go-ipfs-routing v0.1.0 h1:gAJTT1cEeeLj6/DlLX6t+NxD9fQe2ymTO6qWRDI/HQQ= +github.com/ipfs/go-ipfs-routing v0.1.0/go.mod h1:hYoUkJLyAUKhF58tysKpids8RNDPO42BVMgK5dNsoqY= +github.com/ipfs/go-ipfs-util v0.0.1/go.mod h1:spsl5z8KUnrve+73pOhSVZND1SIxPW5RyBCNzQxlJBc= +github.com/ipfs/go-ipld-cbor v0.0.1/go.mod h1:RXHr8s4k0NE0TKhnrxqZC9M888QfsBN9rhS5NjfKzY8= +github.com/ipfs/go-ipld-cbor v0.0.2/go.mod h1:wTBtrQZA3SoFKMVkp6cn6HMRteIB1VsmHA0AQFOn7Nc= +github.com/ipfs/go-ipld-cbor v0.0.3/go.mod h1:wTBtrQZA3SoFKMVkp6cn6HMRteIB1VsmHA0AQFOn7Nc= +github.com/ipfs/go-ipld-cbor v0.0.4 h1:Aw3KPOKXjvrm6VjwJvFf1F1ekR/BH3jdof3Bk7OTiSA= +github.com/ipfs/go-ipld-cbor v0.0.4/go.mod h1:BkCduEx3XBCO6t2Sfo5BaHzuok7hbhdMm9Oh8B2Ftq4= +github.com/ipfs/go-ipld-format v0.0.1/go.mod h1:kyJtbkDALmFHv3QR6et67i35QzO3S0dCDnkOJhcZkms= +github.com/ipfs/go-ipld-format v0.0.2/go.mod h1:4B6+FM2u9OJ9zCV+kSbgFAZlOrv1Hqbf0INGQgiKf9k= +github.com/ipfs/go-ipld-format v0.2.0 h1:xGlJKkArkmBvowr+GMCX0FEZtkro71K1AwiKnL37mwA= +github.com/ipfs/go-ipld-format v0.2.0/go.mod h1:3l3C1uKoadTPbeNfrDi+xMInYKlx2Cvg1BuydPSdzQs= +github.com/ipfs/go-ipld-git v0.0.3 h1:/YjkjCyo5KYRpW+suby8Xh9Cm/iH9dAgGV6qyZ1dGus= +github.com/ipfs/go-ipld-git v0.0.3/go.mod h1:RuvMXa9qtJpDbqngyICCU/d+cmLFXxLsbIclmD0Lcr0= +github.com/ipfs/go-ipns v0.0.2 h1:oq4ErrV4hNQ2Eim257RTYRgfOSV/s8BDaf9iIl4NwFs= +github.com/ipfs/go-ipns v0.0.2/go.mod h1:WChil4e0/m9cIINWLxZe1Jtf77oz5L05rO2ei/uKJ5U= +github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM= +github.com/ipfs/go-log v1.0.1/go.mod h1:HuWlQttfN6FWNHRhlY5yMk/lW7evQC0HHGOxEwMRR8I= +github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk= +github.com/ipfs/go-log v1.0.3 h1:Gg7SUYSZ7BrqaKMwM+hRgcAkKv4QLfzP4XPQt5Sx/OI= +github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A= +github.com/ipfs/go-log v1.0.4 h1:6nLQdX4W8P9yZZFH7mO+X/PzjN8Laozm/lMJ6esdgzY= +github.com/ipfs/go-log v1.0.4/go.mod h1:oDCg2FkjogeFOhqqb+N39l2RpTNPL6F/StPkB3kPgcs= +github.com/ipfs/go-log/v2 v2.0.1/go.mod h1:O7P1lJt27vWHhOwQmcFEvlmo49ry2VY2+JfBWFaa9+0= +github.com/ipfs/go-log/v2 v2.0.2/go.mod h1:O7P1lJt27vWHhOwQmcFEvlmo49ry2VY2+JfBWFaa9+0= +github.com/ipfs/go-log/v2 v2.0.3 h1:Q2gXcBoCALyLN/pUQlz1qgu0x3uFV6FzP9oXhpfyJpc= +github.com/ipfs/go-log/v2 v2.0.3/go.mod h1:O7P1lJt27vWHhOwQmcFEvlmo49ry2VY2+JfBWFaa9+0= +github.com/ipfs/go-log/v2 v2.0.5 h1:fL4YI+1g5V/b1Yxr1qAiXTMg1H8z9vx/VmJxBuQMHvU= +github.com/ipfs/go-log/v2 v2.0.5/go.mod h1:eZs4Xt4ZUJQFM3DlanGhy7TkwwawCZcSByscwkWG+dw= +github.com/ipfs/go-merkledag v0.0.3/go.mod h1:Oc5kIXLHokkE1hWGMBHw+oxehkAaTOqtEb7Zbh6BhLA= +github.com/ipfs/go-merkledag v0.0.6/go.mod h1:QYPdnlvkOg7GnQRofu9XZimC5ZW5Wi3bKys/4GQQfto= +github.com/ipfs/go-merkledag v0.1.0/go.mod h1:SQiXrtSts3KGNmgOzMICy5c0POOpUNQLvB3ClKnBAlk= +github.com/ipfs/go-merkledag v0.2.3/go.mod h1:SQiXrtSts3KGNmgOzMICy5c0POOpUNQLvB3ClKnBAlk= +github.com/ipfs/go-merkledag v0.2.4/go.mod h1:SQiXrtSts3KGNmgOzMICy5c0POOpUNQLvB3ClKnBAlk= +github.com/ipfs/go-merkledag v0.3.0/go.mod h1:4pymaZLhSLNVuiCITYrpViD6vmfZ/Ws4n/L9tfNv3S4= +github.com/ipfs/go-merkledag v0.3.1 h1:3UqWINBEr3/N+r6OwgFXAddDP/8zpQX/8J7IGVOCqRQ= +github.com/ipfs/go-merkledag v0.3.1/go.mod h1:fvkZNNZixVW6cKSZ/JfLlON5OlgTXNdRLz0p6QG/I2M= +github.com/ipfs/go-merkledag v0.3.2 h1:MRqj40QkrWkvPswXs4EfSslhZ4RVPRbxwX11js0t1xY= +github.com/ipfs/go-merkledag v0.3.2/go.mod h1:fvkZNNZixVW6cKSZ/JfLlON5OlgTXNdRLz0p6QG/I2M= +github.com/ipfs/go-metrics-interface v0.0.1/go.mod h1:6s6euYU4zowdslK0GKHmqaIZ3j/b/tL7HTWtJ4VPgWY= +github.com/ipfs/go-metrics-prometheus v0.0.2/go.mod h1:ELLU99AQQNi+zX6GCGm2lAgnzdSH3u5UVlCdqSXnEks= +github.com/ipfs/go-mfs v0.1.1 h1:tjYEWFIl0W6vRFuM/EnySHaaYzPmDcQWwTjtYWMGQ1A= +github.com/ipfs/go-mfs v0.1.1/go.mod h1:nk17h6kCOrfaNqXvx2VJ3SqkJ0VYUzJFAsc+BA0sqaw= +github.com/ipfs/go-path v0.0.3/go.mod h1:zIRQUez3LuQIU25zFjC2hpBTHimWx7VK5bjZgRLbbdo= +github.com/ipfs/go-path v0.0.7 h1:H06hKMquQ0aYtHiHryOMLpQC1qC3QwXwkahcEVD51Ho= +github.com/ipfs/go-path v0.0.7/go.mod h1:6KTKmeRnBXgqrTvzFrPV3CamxcgvXX/4z79tfAd2Sno= +github.com/ipfs/go-peertaskqueue v0.0.4/go.mod h1:03H8fhyeMfKNFWqzYEVyMbcPUeYrqP1MX6Kd+aN+rMQ= +github.com/ipfs/go-peertaskqueue v0.1.0/go.mod h1:Jmk3IyCcfl1W3jTW3YpghSwSEC6IJ3Vzz/jUmWw8Z0U= +github.com/ipfs/go-peertaskqueue v0.1.1/go.mod h1:Jmk3IyCcfl1W3jTW3YpghSwSEC6IJ3Vzz/jUmWw8Z0U= +github.com/ipfs/go-peertaskqueue v0.2.0 h1:2cSr7exUGKYyDeUyQ7P/nHPs9P7Ht/B+ROrpN1EJOjc= +github.com/ipfs/go-peertaskqueue v0.2.0/go.mod h1:5/eNrBEbtSKWCG+kQK8K8fGNixoYUnr+P7jivavs9lY= +github.com/ipfs/go-unixfs v0.0.4/go.mod h1:eIo/p9ADu/MFOuyxzwU+Th8D6xoxU//r590vUpWyfz8= +github.com/ipfs/go-unixfs v0.1.0/go.mod h1:lysk5ELhOso8+Fed9U1QTGey2ocsfaZ18h0NCO2Fj9s= +github.com/ipfs/go-unixfs v0.2.2-0.20190827150610-868af2e9e5cb/go.mod h1:IwAAgul1UQIcNZzKPYZWOCijryFBeCV79cNubPzol+k= +github.com/ipfs/go-unixfs v0.2.4 h1:6NwppOXefWIyysZ4LR/qUBPvXd5//8J3jiMdvpbw6Lo= +github.com/ipfs/go-unixfs v0.2.4/go.mod h1:SUdisfUjNoSDzzhGVxvCL9QO/nKdwXdr+gbMUdqcbYw= +github.com/ipfs/go-verifcid v0.0.1/go.mod h1:5Hrva5KBeIog4A+UpqlaIU+DEstipcJYQQZc0g37pY0= +github.com/ipfs/interface-go-ipfs-core v0.2.6 h1:4eeGPJUDWblEurSzpAtL2znDG1xqAoX2aNNIoOFwyuc= +github.com/ipfs/interface-go-ipfs-core v0.2.6/go.mod h1:Tihp8zxGpUeE3Tokr94L6zWZZdkRQvG5TL6i9MuNE+s= +github.com/ipfs/interface-go-ipfs-core v0.2.7 h1:HCwVmU9Tmba6jdMGxMcPsfwKUBY4y+6bLHp8T+t9hTU= +github.com/ipfs/interface-go-ipfs-core v0.2.7/go.mod h1:Tihp8zxGpUeE3Tokr94L6zWZZdkRQvG5TL6i9MuNE+s= +github.com/ipld/go-car v0.1.0/go.mod h1:RCWzaUh2i4mOEkB3W45Vc+9jnS/M6Qay5ooytiBHl3g= +github.com/ipld/go-ipld-prime v0.0.2-0.20191108012745-28a82f04c785 h1:fASnkvtR+SmB2y453RxmDD3Uvd4LonVUgFGk9JoDaZs= +github.com/ipld/go-ipld-prime v0.0.2-0.20191108012745-28a82f04c785/go.mod h1:bDDSvVz7vaK12FNvMeRYnpRFkSUPNQOiCYQezMD/P3w= +github.com/ipld/go-ipld-prime-proto v0.0.0-20191113031812-e32bd156a1e5 h1:lSip43rAdyGA+yRQuy6ju0ucZkWpYc1F2CTQtZTVW/4= +github.com/ipld/go-ipld-prime-proto v0.0.0-20191113031812-e32bd156a1e5/go.mod h1:gcvzoEDBjwycpXt3LBE061wT9f46szXGHAmj9uoP6fU= +github.com/jackpal/gateway v1.0.4/go.mod h1:lTpwd4ACLXmpyiCTRtfiNyVnUmqT9RivzCDQetPfnjA= +github.com/jackpal/gateway v1.0.5/go.mod h1:lTpwd4ACLXmpyiCTRtfiNyVnUmqT9RivzCDQetPfnjA= +github.com/jackpal/go-nat-pmp v1.0.1/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= +github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc= +github.com/jbenet/go-cienv v0.0.0-20150120210510-1bb1476777ec/go.mod h1:rGaEvXB4uRSZMmzKNLoXvTu1sfx+1kv/DojUlPrSZGs= +github.com/jbenet/go-cienv v0.1.0/go.mod h1:TqNnHUmJgXau0nCzC7kXWeotg3J9W34CUv5Djy1+FlA= +github.com/jbenet/go-is-domain v1.0.3 h1:FuRBJ0h79p00eseyaLckJT5KnE8RyqI+HLopvNSyNE0= +github.com/jbenet/go-is-domain v1.0.3/go.mod h1:xbRLRb0S7FgzDBTJlguhDVwLYM/5yNtvktxj2Ttfy7Q= +github.com/jbenet/go-random v0.0.0-20190219211222-123a90aedc0c h1:uUx61FiAa1GI6ZmVd2wf2vULeQZIKG66eybjNXKYCz4= +github.com/jbenet/go-random v0.0.0-20190219211222-123a90aedc0c/go.mod h1:sdx1xVM9UuLw1tXnhJWN3piypTUO3vCIHYmG15KE/dU= +github.com/jbenet/go-temp-err-catcher v0.0.0-20150120210811-aac704a3f4f2/go.mod h1:8GXXJV31xl8whumTzdZsTt3RnUIiPqzkyf7mxToRCMs= +github.com/jbenet/go-temp-err-catcher v0.1.0 h1:zpb3ZH6wIE8Shj2sKS+khgRvf7T7RABoLk/+KKHggpk= +github.com/jbenet/go-temp-err-catcher v0.1.0/go.mod h1:0kJRvmDZXNMIiJirNPEYfhpPwbGVtZVWC34vc5WLsDk= +github.com/jbenet/goprocess v0.0.0-20160826012719-b497e2f366b8/go.mod h1:Ly/wlsjFq/qrU3Rar62tu1gASgGw6chQbSh/XgIIXCY= +github.com/jbenet/goprocess v0.1.3/go.mod h1:5yspPrukOVuOLORacaBi858NqyClJPQxYZlqdZVfqY4= +github.com/jbenet/goprocess v0.1.4 h1:DRGOFReOMqqDNXwW70QkacFW0YN9QnwLV0Vqk+3oU0o= +github.com/jbenet/goprocess v0.1.4/go.mod h1:5yspPrukOVuOLORacaBi858NqyClJPQxYZlqdZVfqY4= +github.com/jellevandenhooff/dkim v0.0.0-20150330215556-f50fe3d243e1/go.mod h1:E0B/fFc00Y+Rasa88328GlI/XbtyysCtTHZS8h7IrBU= +github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= +github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= +github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ= +github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= +github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= +github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= +github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= +github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo= +github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= +github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= +github.com/kami-zh/go-capturer v0.0.0-20171211120116-e492ea43421d/go.mod h1:P2viExyCEfeWGU259JnaQ34Inuec4R38JCyBx2edgD0= +github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q= +github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4= +github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/koron/go-ssdp v0.0.0-20180514024734-4a0ed625a78b/go.mod h1:5Ky9EC2xfoUKUor0Hjgi2BJhCSXJfMOFlmyYrVKGQMk= +github.com/koron/go-ssdp v0.0.0-20191105050749-2e1c40ed0b5d h1:68u9r4wEvL3gYg2jvAOgROwZ3H+Y3hIDk4tbbmIjcYQ= +github.com/koron/go-ssdp v0.0.0-20191105050749-2e1c40ed0b5d/go.mod h1:5Ky9EC2xfoUKUor0Hjgi2BJhCSXJfMOFlmyYrVKGQMk= +github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pretty v0.2.0 h1:s5hAObm+yFO5uHYt5dYjxi2rXrsnmRpJx4OYvIWUaQs= +github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/pty v1.1.3/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/libp2p/go-addr-util v0.0.1 h1:TpTQm9cXVRVSKsYbgQ7GKc3KbbHVTnbostgGaDEP+88= +github.com/libp2p/go-addr-util v0.0.1/go.mod h1:4ac6O7n9rIAKB1dnd+s8IbbMXkt+oBpzX4/+RACcnlQ= +github.com/libp2p/go-buffer-pool v0.0.1/go.mod h1:xtyIz9PMobb13WaxR6Zo1Pd1zXJKYg0a8KiIvDp3TzQ= +github.com/libp2p/go-buffer-pool v0.0.2 h1:QNK2iAFa8gjAe1SPz6mHSMuCcjs+X1wlHzeOSqcmlfs= +github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoRZd1Vi32+RXyFM= +github.com/libp2p/go-conn-security v0.0.1/go.mod h1:bGmu51N0KU9IEjX7kl2PQjgZa40JQWnayTvNMgD/vyk= +github.com/libp2p/go-conn-security-multistream v0.0.1/go.mod h1:nc9vud7inQ+d6SO0I/6dSWrdMnHnzZNHeyUQqrAJulE= +github.com/libp2p/go-conn-security-multistream v0.0.2/go.mod h1:nc9vud7inQ+d6SO0I/6dSWrdMnHnzZNHeyUQqrAJulE= +github.com/libp2p/go-conn-security-multistream v0.1.0 h1:aqGmto+ttL/uJgX0JtQI0tD21CIEy5eYd1Hlp0juHY0= +github.com/libp2p/go-conn-security-multistream v0.1.0/go.mod h1:aw6eD7LOsHEX7+2hJkDxw1MteijaVcI+/eP2/x3J1xc= +github.com/libp2p/go-conn-security-multistream v0.2.0 h1:uNiDjS58vrvJTg9jO6bySd1rMKejieG7v45ekqHbZ1M= +github.com/libp2p/go-conn-security-multistream v0.2.0/go.mod h1:hZN4MjlNetKD3Rq5Jb/P5ohUnFLNzEAR4DLSzpn2QLU= +github.com/libp2p/go-eventbus v0.0.2/go.mod h1:Hr/yGlwxA/stuLnpMiu82lpNKpvRy3EaJxPu40XYOwk= +github.com/libp2p/go-eventbus v0.0.3/go.mod h1:Hr/yGlwxA/stuLnpMiu82lpNKpvRy3EaJxPu40XYOwk= +github.com/libp2p/go-eventbus v0.1.0 h1:mlawomSAjjkk97QnYiEmHsLu7E136+2oCWSHRUvMfzQ= +github.com/libp2p/go-eventbus v0.1.0/go.mod h1:vROgu5cs5T7cv7POWlWxBaVLxfSegC5UGQf8A2eEmx4= +github.com/libp2p/go-flow-metrics v0.0.1/go.mod h1:Iv1GH0sG8DtYN3SVJ2eG221wMiNpZxBdp967ls1g+k8= +github.com/libp2p/go-flow-metrics v0.0.2/go.mod h1:HeoSNUrOJVK1jEpDqVEiUOIXqhbnS27omG0uWU5slZs= +github.com/libp2p/go-flow-metrics v0.0.3 h1:8tAs/hSdNvUiLgtlSy3mxwxWP4I9y/jlkPFT7epKdeM= +github.com/libp2p/go-flow-metrics v0.0.3/go.mod h1:HeoSNUrOJVK1jEpDqVEiUOIXqhbnS27omG0uWU5slZs= +github.com/libp2p/go-libp2p v0.0.2/go.mod h1:Qu8bWqFXiocPloabFGUcVG4kk94fLvfC8mWTDdFC9wE= +github.com/libp2p/go-libp2p v0.0.30/go.mod h1:XWT8FGHlhptAv1+3V/+J5mEpzyui/5bvFsNuWYs611A= +github.com/libp2p/go-libp2p v0.1.0/go.mod h1:6D/2OBauqLUoqcADOJpn9WbKqvaM07tDw68qHM0BxUM= +github.com/libp2p/go-libp2p v0.1.1/go.mod h1:I00BRo1UuUSdpuc8Q2mN7yDF/oTUTRAX6JWpTiK9Rp8= +github.com/libp2p/go-libp2p v0.2.1/go.mod h1:HZbtEOrgZN4F1fGZVvkV+930Wx3DkqlpBlO8dIoZWds= +github.com/libp2p/go-libp2p v0.6.0/go.mod h1:mfKWI7Soz3ABX+XEBR61lGbg+ewyMtJHVt043oWeqwg= +github.com/libp2p/go-libp2p v0.6.1/go.mod h1:CTFnWXogryAHjXAKEbOf1OWY+VeAP3lDMZkfEI5sT54= +github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xSU1ivxn0k= +github.com/libp2p/go-libp2p v0.7.4 h1:xVj1oSlN0C+FlxqiLuHC8WruMvq24xxfeVxmNhTG0r0= +github.com/libp2p/go-libp2p v0.7.4/go.mod h1:oXsBlTLF1q7pxr+9w6lqzS1ILpyHsaBPniVO7zIHGMw= +github.com/libp2p/go-libp2p v0.8.2/go.mod h1:NQDA/F/qArMHGe0J7sDScaKjW8Jh4y/ozQqBbYJ+BnA= +github.com/libp2p/go-libp2p v0.8.3 h1:IFWeNzxkBaNO1N8stN9ayFGdC6RmVuSsKd5bou7qpK0= +github.com/libp2p/go-libp2p v0.8.3/go.mod h1:EsH1A+8yoWK+L4iKcbPYu6MPluZ+CHWI9El8cTaefiM= +github.com/libp2p/go-libp2p-autonat v0.0.2/go.mod h1:fs71q5Xk+pdnKU014o2iq1RhMs9/PMaG5zXRFNnIIT4= +github.com/libp2p/go-libp2p-autonat v0.0.6/go.mod h1:uZneLdOkZHro35xIhpbtTzLlgYturpu4J5+0cZK3MqE= +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= +github.com/libp2p/go-libp2p-autonat v0.2.1 h1:T0CRQhrvTBKfBSYw6Xo2K3ixtNpAnRCraxof3AAfgQA= +github.com/libp2p/go-libp2p-autonat v0.2.1/go.mod h1:MWtAhV5Ko1l6QBsHQNSuM6b1sRkXrpk0/LqCr+vCVxI= +github.com/libp2p/go-libp2p-autonat v0.2.2 h1:4dlgcEEugTFWSvdG2UIFxhnOMpX76QaZSRAtXmYB8n4= +github.com/libp2p/go-libp2p-autonat v0.2.2/go.mod h1:HsM62HkqZmHR2k1xgX34WuWDzk/nBwNHoeyyT4IWV6A= +github.com/libp2p/go-libp2p-blankhost v0.0.1/go.mod h1:Ibpbw/7cPPYwFb7PACIWdvxxv0t0XCCI10t7czjAjTc= +github.com/libp2p/go-libp2p-blankhost v0.1.1/go.mod h1:pf2fvdLJPsC1FsVrNP3DUUvMzUts2dsLLBEpo1vW1ro= +github.com/libp2p/go-libp2p-blankhost v0.1.3/go.mod h1:KML1//wiKR8vuuJO0y3LUd1uLv+tlkGTAr3jC0S5cLg= +github.com/libp2p/go-libp2p-blankhost v0.1.4 h1:I96SWjR4rK9irDHcHq3XHN6hawCRTPUADzkJacgZLvk= +github.com/libp2p/go-libp2p-blankhost v0.1.4/go.mod h1:oJF0saYsAXQCSfDq254GMNmLNz6ZTHTOvtF4ZydUvwU= +github.com/libp2p/go-libp2p-circuit v0.0.1/go.mod h1:Dqm0s/BiV63j8EEAs8hr1H5HudqvCAeXxDyic59lCwE= +github.com/libp2p/go-libp2p-circuit v0.0.9/go.mod h1:uU+IBvEQzCu953/ps7bYzC/D/R0Ho2A9LfKVVCatlqU= +github.com/libp2p/go-libp2p-circuit v0.1.0/go.mod h1:Ahq4cY3V9VJcHcn1SBXjr78AbFkZeIRmfunbA7pmFh8= +github.com/libp2p/go-libp2p-circuit v0.1.4/go.mod h1:CY67BrEjKNDhdTk8UgBX1Y/H5c3xkAcs3gnksxY7osU= +github.com/libp2p/go-libp2p-circuit v0.2.1 h1:BDiBcQxX/ZJJ/yDl3sqZt1bjj4PkZCEi7IEpwxXr13k= +github.com/libp2p/go-libp2p-circuit v0.2.1/go.mod h1:BXPwYDN5A8z4OEY9sOfr2DUQMLQvKt/6oku45YUmjIo= +github.com/libp2p/go-libp2p-circuit v0.2.2 h1:87RLabJ9lrhoiSDDZyCJ80ZlI5TLJMwfyoGAaWXzWqA= +github.com/libp2p/go-libp2p-circuit v0.2.2/go.mod h1:nkG3iE01tR3FoQ2nMm06IUrCpCyJp1Eo4A1xYdpjfs4= +github.com/libp2p/go-libp2p-connmgr v0.2.1 h1:1ed0HFhCb39sIMK7QYgRBW0vibBBqFQMs4xt9a9AalY= +github.com/libp2p/go-libp2p-connmgr v0.2.1/go.mod h1:JReKEFcgzSHKT9lL3rhYcUtXBs9uMIiMKJGM1tl3xJE= +github.com/libp2p/go-libp2p-core v0.0.1/go.mod h1:g/VxnTZ/1ygHxH3dKok7Vno1VfpvGcGip57wjTU4fco= +github.com/libp2p/go-libp2p-core v0.0.2/go.mod h1:9dAcntw/n46XycV4RnlBq3BpgrmyUi9LuoTNdPrbUco= +github.com/libp2p/go-libp2p-core v0.0.3/go.mod h1:j+YQMNz9WNSkNezXOsahp9kwZBKBvxLpKD316QWSJXE= +github.com/libp2p/go-libp2p-core v0.0.4/go.mod h1:jyuCQP356gzfCFtRKyvAbNkyeuxb7OlyhWZ3nls5d2I= +github.com/libp2p/go-libp2p-core v0.0.6/go.mod h1:0d9xmaYAVY5qmbp/fcgxHT3ZJsLjYeYPMJAUKpaCHrE= +github.com/libp2p/go-libp2p-core v0.0.9/go.mod h1:0d9xmaYAVY5qmbp/fcgxHT3ZJsLjYeYPMJAUKpaCHrE= +github.com/libp2p/go-libp2p-core v0.2.0/go.mod h1:X0eyB0Gy93v0DZtSYbEM7RnMChm9Uv3j7yRXjO77xSI= +github.com/libp2p/go-libp2p-core v0.2.2/go.mod h1:8fcwTbsG2B+lTgRJ1ICZtiM5GWCWZVoVrLaDRvIRng0= +github.com/libp2p/go-libp2p-core v0.2.4/go.mod h1:STh4fdfa5vDYr0/SzYYeqnt+E6KfEV5VxfIrm0bcI0g= +github.com/libp2p/go-libp2p-core v0.2.5/go.mod h1:6+5zJmKhsf7yHn1RbmYDu08qDUpIUxGdqHuEZckmZOA= +github.com/libp2p/go-libp2p-core v0.3.0/go.mod h1:ACp3DmS3/N64c2jDzcV429ukDpicbL6+TrrxANBjPGw= +github.com/libp2p/go-libp2p-core v0.3.1/go.mod h1:thvWy0hvaSBhnVBaW37BvzgVV68OUhgJJLAa6almrII= +github.com/libp2p/go-libp2p-core v0.4.0/go.mod h1:49XGI+kc38oGVwqSBhDEwytaAxgZasHhFfQKibzTls0= +github.com/libp2p/go-libp2p-core v0.5.0/go.mod h1:49XGI+kc38oGVwqSBhDEwytaAxgZasHhFfQKibzTls0= +github.com/libp2p/go-libp2p-core v0.5.1 h1:6Cu7WljPQtGY2krBlMoD8L/zH3tMUsCbqNFH7cZwCoI= +github.com/libp2p/go-libp2p-core v0.5.1/go.mod h1:uN7L2D4EvPCvzSH5SrhR72UWbnSGpt5/a35Sm4upn4Y= +github.com/libp2p/go-libp2p-core v0.5.2 h1:hevsCcdLiazurKBoeNn64aPYTVOPdY4phaEGeLtHOAs= +github.com/libp2p/go-libp2p-core v0.5.2/go.mod h1:uN7L2D4EvPCvzSH5SrhR72UWbnSGpt5/a35Sm4upn4Y= +github.com/libp2p/go-libp2p-crypto v0.0.1/go.mod h1:yJkNyDmO341d5wwXxDUGO0LykUVT72ImHNUqh5D/dBE= +github.com/libp2p/go-libp2p-crypto v0.0.2/go.mod h1:eETI5OUfBnvARGOHrJz2eWNyTUxEGZnBxMcbUjfIj4I= +github.com/libp2p/go-libp2p-crypto v0.1.0 h1:k9MFy+o2zGDNGsaoZl0MA3iZ75qXxr9OOoAZF+sD5OQ= +github.com/libp2p/go-libp2p-crypto v0.1.0/go.mod h1:sPUokVISZiy+nNuTTH/TY+leRSxnFj/2GLjtOTW90hI= +github.com/libp2p/go-libp2p-discovery v0.0.1/go.mod h1:ZkkF9xIFRLA1xCc7bstYFkd80gBGK8Fc1JqGoU2i+zI= +github.com/libp2p/go-libp2p-discovery v0.0.5/go.mod h1:YtF20GUxjgoKZ4zmXj8j3Nb2TUSBHFlOCetzYdbZL5I= +github.com/libp2p/go-libp2p-discovery v0.1.0/go.mod h1:4F/x+aldVHjHDHuX85x1zWoFTGElt8HnoDzwkFZm29g= +github.com/libp2p/go-libp2p-discovery v0.2.0/go.mod h1:s4VGaxYMbw4+4+tsoQTqh7wfxg97AEdo4GYBt6BadWg= +github.com/libp2p/go-libp2p-discovery v0.3.0 h1:+JnYBRLzZQtRq0mK3xhyjBwHytLmJXMTZkQfbw+UrGA= +github.com/libp2p/go-libp2p-discovery v0.3.0/go.mod h1:o03drFnz9BVAZdzC/QUQ+NeQOu38Fu7LJGEOK2gQltw= +github.com/libp2p/go-libp2p-discovery v0.4.0 h1:dK78UhopBk48mlHtRCzbdLm3q/81g77FahEBTjcqQT8= +github.com/libp2p/go-libp2p-discovery v0.4.0/go.mod h1:bZ0aJSrFc/eX2llP0ryhb1kpgkPyTo23SJ5b7UQCMh4= +github.com/libp2p/go-libp2p-gostream v0.2.1/go.mod h1:1Mjp3LDmkqICe5tH9yLVNCqFaRTy6OwBvuJV6j1b9Nk= +github.com/libp2p/go-libp2p-host v0.0.1/go.mod h1:qWd+H1yuU0m5CwzAkvbSjqKairayEHdR5MMl7Cwa7Go= +github.com/libp2p/go-libp2p-host v0.0.3/go.mod h1:Y/qPyA6C8j2coYyos1dfRm0I8+nvd4TGrDGt4tA7JR8= +github.com/libp2p/go-libp2p-http v0.1.5/go.mod h1:2YfPjsQxUlBGFQl2u461unkQ7ukwiSs7NX2eSslOJiU= +github.com/libp2p/go-libp2p-interface-connmgr v0.0.1/go.mod h1:GarlRLH0LdeWcLnYM/SaBykKFl9U5JFnbBGruAk/D5k= +github.com/libp2p/go-libp2p-interface-connmgr v0.0.4/go.mod h1:GarlRLH0LdeWcLnYM/SaBykKFl9U5JFnbBGruAk/D5k= +github.com/libp2p/go-libp2p-interface-connmgr v0.0.5/go.mod h1:GarlRLH0LdeWcLnYM/SaBykKFl9U5JFnbBGruAk/D5k= +github.com/libp2p/go-libp2p-interface-pnet v0.0.1/go.mod h1:el9jHpQAXK5dnTpKA4yfCNBZXvrzdOU75zz+C6ryp3k= +github.com/libp2p/go-libp2p-kad-dht v0.6.2 h1:ZKXN7iqjIGC3+z4MKoBoyOGq6zvJ294J/tAA7LfihV0= +github.com/libp2p/go-libp2p-kad-dht v0.6.2/go.mod h1:LzZi6RR6NrgfFboyk03I5Yzg1Rr4eoQictDXpKpI45c= +github.com/libp2p/go-libp2p-kad-dht v0.7.10 h1:Usixca9o8e3t+pSdHkzyWdU+WSbeTaMvpIcXxQrbImE= +github.com/libp2p/go-libp2p-kad-dht v0.7.10/go.mod h1:COi43/398wedaaNzvnbnWQ8qeG629Nu7Aj0WixHmD3A= +github.com/libp2p/go-libp2p-kbucket v0.3.3 h1:V2Zwv6QnCK6Who0iiJW2eUKwdlTYGJ2HnLViaolDOcs= +github.com/libp2p/go-libp2p-kbucket v0.3.3/go.mod h1:IWFdYRBOYzaLEHnvrfzEkr+UcuveCXIoeO8QeFZSI6A= +github.com/libp2p/go-libp2p-kbucket v0.4.1 h1:6FyzbQuGLPzbMv3HiD232zqscIz5iB8ppJwb380+OGI= +github.com/libp2p/go-libp2p-kbucket v0.4.1/go.mod h1:7sCeZx2GkNK1S6lQnGUW5JYZCFPnXzAZCCBBS70lytY= +github.com/libp2p/go-libp2p-loggables v0.0.1/go.mod h1:lDipDlBNYbpyqyPX/KcoO+eq0sJYEVR2JgOexcivchg= +github.com/libp2p/go-libp2p-loggables v0.1.0 h1:h3w8QFfCt2UJl/0/NW4K829HX/0S4KD31PQ7m8UXXO8= +github.com/libp2p/go-libp2p-loggables v0.1.0/go.mod h1:EyumB2Y6PrYjr55Q3/tiJ/o3xoDasoRYM7nOzEpoa90= +github.com/libp2p/go-libp2p-metrics v0.0.1/go.mod h1:jQJ95SXXA/K1VZi13h52WZMa9ja78zjyy5rspMsC/08= +github.com/libp2p/go-libp2p-mplex v0.1.1/go.mod h1:KUQWpGkCzfV7UIpi8SKsAVxyBgz1c9R5EvxgnwLsb/I= +github.com/libp2p/go-libp2p-mplex v0.2.0/go.mod h1:Ejl9IyjvXJ0T9iqUTE1jpYATQ9NM3g+OtR+EMMODbKo= +github.com/libp2p/go-libp2p-mplex v0.2.1/go.mod h1:SC99Rxs8Vuzrf/6WhmH41kNn13TiYdAWNYHrwImKLnE= +github.com/libp2p/go-libp2p-mplex v0.2.2/go.mod h1:74S9eum0tVQdAfFiKxAyKzNdSuLqw5oadDq7+L/FELo= +github.com/libp2p/go-libp2p-mplex v0.2.3 h1:2zijwaJvpdesST2MXpI5w9wWFRgYtMcpRX7rrw0jmOo= +github.com/libp2p/go-libp2p-mplex v0.2.3/go.mod h1:CK3p2+9qH9x+7ER/gWWDYJ3QW5ZxWDkm+dVvjfuG3ek= +github.com/libp2p/go-libp2p-nat v0.0.2/go.mod h1:QrjXQSD5Dj4IJOdEcjHRkWTSomyxRo6HnUkf/TfQpLQ= +github.com/libp2p/go-libp2p-nat v0.0.4/go.mod h1:N9Js/zVtAXqaeT99cXgTV9e75KpnWCvVOiGzlcHmBbY= +github.com/libp2p/go-libp2p-nat v0.0.5/go.mod h1:1qubaE5bTZMJE+E/uu2URroMbzdubFz1ChgiN79yKPE= +github.com/libp2p/go-libp2p-nat v0.0.6 h1:wMWis3kYynCbHoyKLPBEMu4YRLltbm8Mk08HGSfvTkU= +github.com/libp2p/go-libp2p-nat v0.0.6/go.mod h1:iV59LVhB3IkFvS6S6sauVTSOrNEANnINbI/fkaLimiw= +github.com/libp2p/go-libp2p-net v0.0.1/go.mod h1:Yt3zgmlsHOgUWSXmt5V/Jpz9upuJBE8EgNU9DrCcR8c= +github.com/libp2p/go-libp2p-net v0.0.2/go.mod h1:Yt3zgmlsHOgUWSXmt5V/Jpz9upuJBE8EgNU9DrCcR8c= +github.com/libp2p/go-libp2p-netutil v0.0.1/go.mod h1:GdusFvujWZI9Vt0X5BKqwWWmZFxecf9Gt03cKxm2f/Q= +github.com/libp2p/go-libp2p-netutil v0.1.0 h1:zscYDNVEcGxyUpMd0JReUZTrpMfia8PmLKcKF72EAMQ= +github.com/libp2p/go-libp2p-netutil v0.1.0/go.mod h1:3Qv/aDqtMLTUyQeundkKsA+YCThNdbQD54k3TqjpbFU= +github.com/libp2p/go-libp2p-peer v0.0.1/go.mod h1:nXQvOBbwVqoP+T5Y5nCjeH4sP9IX/J0AMzcDUVruVoo= +github.com/libp2p/go-libp2p-peer v0.1.1/go.mod h1:jkF12jGB4Gk/IOo+yomm+7oLWxF278F7UnrYUQ1Q8es= +github.com/libp2p/go-libp2p-peer v0.2.0 h1:EQ8kMjaCUwt/Y5uLgjT8iY2qg0mGUT0N1zUjer50DsY= +github.com/libp2p/go-libp2p-peer v0.2.0/go.mod h1:RCffaCvUyW2CJmG2gAWVqwePwW7JMgxjsHm7+J5kjWY= +github.com/libp2p/go-libp2p-peerstore v0.0.1/go.mod h1:RabLyPVJLuNQ+GFyoEkfi8H4Ti6k/HtZJ7YKgtSq+20= +github.com/libp2p/go-libp2p-peerstore v0.0.6/go.mod h1:RabLyPVJLuNQ+GFyoEkfi8H4Ti6k/HtZJ7YKgtSq+20= +github.com/libp2p/go-libp2p-peerstore v0.1.0/go.mod h1:2CeHkQsr8svp4fZ+Oi9ykN1HBb6u0MOvdJ7YIsmcwtY= +github.com/libp2p/go-libp2p-peerstore v0.1.2/go.mod h1:BJ9sHlm59/80oSkpWgr1MyY1ciXAXV397W6h1GH/uKI= +github.com/libp2p/go-libp2p-peerstore v0.1.3/go.mod h1:BJ9sHlm59/80oSkpWgr1MyY1ciXAXV397W6h1GH/uKI= +github.com/libp2p/go-libp2p-peerstore v0.1.4/go.mod h1:+4BDbDiiKf4PzpANZDAT+knVdLxvqh7hXOujessqdzs= +github.com/libp2p/go-libp2p-peerstore v0.2.0/go.mod h1:N2l3eVIeAitSg3Pi2ipSrJYnqhVnMNQZo9nkSCuAbnQ= +github.com/libp2p/go-libp2p-peerstore v0.2.1/go.mod h1:NQxhNjWxf1d4w6PihR8btWIRjwRLBr4TYKfNgrUkOPA= +github.com/libp2p/go-libp2p-peerstore v0.2.2/go.mod h1:NQxhNjWxf1d4w6PihR8btWIRjwRLBr4TYKfNgrUkOPA= +github.com/libp2p/go-libp2p-peerstore v0.2.3 h1:MofRq2l3c15vQpEygTetV+zRRrncz+ktiXW7H2EKoEQ= +github.com/libp2p/go-libp2p-peerstore v0.2.3/go.mod h1:K8ljLdFn590GMttg/luh4caB/3g0vKuY01psze0upRw= +github.com/libp2p/go-libp2p-pnet v0.2.0 h1:J6htxttBipJujEjz1y0a5+eYoiPcFHhSYHH6na5f0/k= +github.com/libp2p/go-libp2p-pnet v0.2.0/go.mod h1:Qqvq6JH/oMZGwqs3N1Fqhv8NVhrdYcO0BW4wssv21LA= +github.com/libp2p/go-libp2p-protocol v0.0.1/go.mod h1:Af9n4PiruirSDjHycM1QuiMi/1VZNHYcK8cLgFJLZ4s= +github.com/libp2p/go-libp2p-protocol v0.1.0/go.mod h1:KQPHpAabB57XQxGrXCNvbL6UEXfQqUgC/1adR2Xtflk= +github.com/libp2p/go-libp2p-pubsub v0.2.5/go.mod h1:9Q2RRq8ofXkoewORcyVlgUFDKLKw7BuYSlJVWRcVk3Y= +github.com/libp2p/go-libp2p-pubsub v0.2.6 h1:ypZaukCFrtD8cNeeb9nnWG4MD2Y1T0p22aQ+f7FKJig= +github.com/libp2p/go-libp2p-pubsub v0.2.6/go.mod h1:5jEp7R3ItQ0pgcEMrPZYE9DQTg/H3CTc7Mu1j2G4Y5o= +github.com/libp2p/go-libp2p-pubsub v0.2.7 h1:PBuK5+NfWsoaoEaAUZ7YQPETQh8UqBi8CbMJ1CZ5sNI= +github.com/libp2p/go-libp2p-pubsub v0.2.7/go.mod h1:R4R0kH/6p2vu8O9xsue0HNSjEuXMEPBgg4h3nVDI15o= +github.com/libp2p/go-libp2p-pubsub-router v0.2.1 h1:F5JYaHQuuMKVbSgLsH2POQwT1rloWpc7fUCOq6PBjyE= +github.com/libp2p/go-libp2p-pubsub-router v0.2.1/go.mod h1:cl46APmxgKgzgpCGFb8Ns7++cqnJ29CxESXCQATp55k= +github.com/libp2p/go-libp2p-quic-transport v0.3.3 h1:A920y1nion8PkGKsEnMiho+3OHpXUqfy35YnPfta4aI= +github.com/libp2p/go-libp2p-quic-transport v0.3.3/go.mod h1:DqzycUAZfeuritygmSOh3kPrs/Cqvc0V1uGkoCEGUXI= +github.com/libp2p/go-libp2p-quic-transport v0.3.5 h1:zu1XFNE9FX8AaR/cptzD2P4uFvtDPj8ivQnZC+IhgsQ= +github.com/libp2p/go-libp2p-quic-transport v0.3.5/go.mod h1:cZNHoobzHTzkQhGnkHB1Kv349N6ESPCpE0TtAk0uRU0= +github.com/libp2p/go-libp2p-record v0.0.1/go.mod h1:grzqg263Rug/sRex85QrDOLntdFAymLDLm7lxMgU79Q= +github.com/libp2p/go-libp2p-record v0.1.0/go.mod h1:ujNc8iuE5dlKWVy6wuL6dd58t0n7xI4hAIl8pE6wu5Q= +github.com/libp2p/go-libp2p-record v0.1.2 h1:M50VKzWnmUrk/M5/Dz99qO9Xh4vs8ijsK+7HkJvRP+0= +github.com/libp2p/go-libp2p-record v0.1.2/go.mod h1:pal0eNcT5nqZaTV7UGhqeGqxFgGdsU/9W//C8dqjQDk= +github.com/libp2p/go-libp2p-routing v0.0.1/go.mod h1:N51q3yTr4Zdr7V8Jt2JIktVU+3xBBylx1MZeVA6t1Ys= +github.com/libp2p/go-libp2p-routing-helpers v0.2.0 h1:+QKTsx2Bg0q3oueQ9CopTwKN5NsnF+qEC+sbkSVXnsU= +github.com/libp2p/go-libp2p-routing-helpers v0.2.0/go.mod h1:Db+7LRSPImkV9fOKsNWVW5IXyy9XDse92lUtO3O+jlo= +github.com/libp2p/go-libp2p-routing-helpers v0.2.1/go.mod h1:rTLUHlGDZbXHANJAWP2xW7ruPNJLj41/GnCBiR+qgjU= +github.com/libp2p/go-libp2p-routing-helpers v0.2.2 h1:gG4g5tyk3dS0iLdyOfsbGYDB6FyuiBcFUJhxX6QHEa4= +github.com/libp2p/go-libp2p-routing-helpers v0.2.2/go.mod h1:rTLUHlGDZbXHANJAWP2xW7ruPNJLj41/GnCBiR+qgjU= +github.com/libp2p/go-libp2p-secio v0.0.1/go.mod h1:IdG6iQybdcYmbTzxp4J5dwtUEDTOvZrT0opIDVNPrJs= +github.com/libp2p/go-libp2p-secio v0.0.3/go.mod h1:hS7HQ00MgLhRO/Wyu1bTX6ctJKhVpm+j2/S2A5UqYb0= +github.com/libp2p/go-libp2p-secio v0.1.0/go.mod h1:tMJo2w7h3+wN4pgU2LSYeiKPrfqBgkOsdiKK77hE7c8= +github.com/libp2p/go-libp2p-secio v0.1.1/go.mod h1:tMJo2w7h3+wN4pgU2LSYeiKPrfqBgkOsdiKK77hE7c8= +github.com/libp2p/go-libp2p-secio v0.2.0/go.mod h1:2JdZepB8J5V9mBp79BmwsaPQhRPNN2NrnB2lKQcdy6g= +github.com/libp2p/go-libp2p-secio v0.2.1/go.mod h1:cWtZpILJqkqrSkiYcDBh5lA3wbT2Q+hz3rJQq3iftD8= +github.com/libp2p/go-libp2p-secio v0.2.2 h1:rLLPvShPQAcY6eNurKNZq3eZjPWfU9kXF2eI9jIYdrg= +github.com/libp2p/go-libp2p-secio v0.2.2/go.mod h1:wP3bS+m5AUnFA+OFO7Er03uO1mncHG0uVwGrwvjYlNY= +github.com/libp2p/go-libp2p-swarm v0.0.1/go.mod h1:mh+KZxkbd3lQnveQ3j2q60BM1Cw2mX36XXQqwfPOShs= +github.com/libp2p/go-libp2p-swarm v0.0.6/go.mod h1:s5GZvzg9xXe8sbeESuFpjt8CJPTCa8mhEusweJqyFy8= +github.com/libp2p/go-libp2p-swarm v0.1.0/go.mod h1:wQVsCdjsuZoc730CgOvh5ox6K8evllckjebkdiY5ta4= +github.com/libp2p/go-libp2p-swarm v0.1.1/go.mod h1:4NVJaLwq/dr5kEq79Jo6pMin7ZFwLx73ln1FTefR91Q= +github.com/libp2p/go-libp2p-swarm v0.2.2/go.mod h1:fvmtQ0T1nErXym1/aa1uJEyN7JzaTNyBcHImCxRpPKU= +github.com/libp2p/go-libp2p-swarm v0.2.3 h1:uVkCb8Blfg7HQ/f30TyHn1g/uCwXsAET7pU0U59gx/A= +github.com/libp2p/go-libp2p-swarm v0.2.3/go.mod h1:P2VO/EpxRyDxtChXz/VPVXyTnszHvokHKRhfkEgFKNM= +github.com/libp2p/go-libp2p-testing v0.0.1/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E= +github.com/libp2p/go-libp2p-testing v0.0.2/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E= +github.com/libp2p/go-libp2p-testing v0.0.3/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E= +github.com/libp2p/go-libp2p-testing v0.0.4/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E= +github.com/libp2p/go-libp2p-testing v0.1.0/go.mod h1:xaZWMJrPUM5GlDBxCeGUi7kI4eqnjVyavGroI2nxEM0= +github.com/libp2p/go-libp2p-testing v0.1.1 h1:U03z3HnGI7Ni8Xx6ONVZvUFOAzWYmolWf5W5jAOPNmU= +github.com/libp2p/go-libp2p-testing v0.1.1/go.mod h1:xaZWMJrPUM5GlDBxCeGUi7kI4eqnjVyavGroI2nxEM0= +github.com/libp2p/go-libp2p-tls v0.1.3 h1:twKMhMu44jQO+HgQK9X8NHO5HkeJu2QbhLzLJpa8oNM= +github.com/libp2p/go-libp2p-tls v0.1.3/go.mod h1:wZfuewxOndz5RTnCAxFliGjvYSDA40sKitV4c50uI1M= +github.com/libp2p/go-libp2p-transport v0.0.1/go.mod h1:UzbUs9X+PHOSw7S3ZmeOxfnwaQY5vGDzZmKPod3N3tk= +github.com/libp2p/go-libp2p-transport v0.0.4/go.mod h1:StoY3sx6IqsP6XKoabsPnHCwqKXWUMWU7Rfcsubee/A= +github.com/libp2p/go-libp2p-transport v0.0.5/go.mod h1:StoY3sx6IqsP6XKoabsPnHCwqKXWUMWU7Rfcsubee/A= +github.com/libp2p/go-libp2p-transport-upgrader v0.0.1/go.mod h1:NJpUAgQab/8K6K0m+JmZCe5RUXG10UMEx4kWe9Ipj5c= +github.com/libp2p/go-libp2p-transport-upgrader v0.0.4/go.mod h1:RGq+tupk+oj7PzL2kn/m1w6YXxcIAYJYeI90h6BGgUc= +github.com/libp2p/go-libp2p-transport-upgrader v0.1.1/go.mod h1:IEtA6or8JUbsV07qPW4r01GnTenLW4oi3lOPbUMGJJA= +github.com/libp2p/go-libp2p-transport-upgrader v0.2.0 h1:5EhPgQhXZNyfL22ERZTUoVp9UVVbNowWNVtELQaKCHk= +github.com/libp2p/go-libp2p-transport-upgrader v0.2.0/go.mod h1:mQcrHj4asu6ArfSoMuyojOdjx73Q47cYD7s5+gZOlns= +github.com/libp2p/go-libp2p-yamux v0.1.2/go.mod h1:xUoV/RmYkg6BW/qGxA9XJyg+HzXFYkeXbnhjmnYzKp8= +github.com/libp2p/go-libp2p-yamux v0.1.3/go.mod h1:VGSQVrqkh6y4nm0189qqxMtvyBft44MOYYPpYKXiVt4= +github.com/libp2p/go-libp2p-yamux v0.2.0/go.mod h1:Db2gU+XfLpm6E4rG5uGCFX6uXA8MEXOxFcRoXUODaK8= +github.com/libp2p/go-libp2p-yamux v0.2.1/go.mod h1:1FBXiHDk1VyRM1C0aez2bCfHQ4vMZKkAQzZbkSQt5fI= +github.com/libp2p/go-libp2p-yamux v0.2.2/go.mod h1:lIohaR0pT6mOt0AZ0L2dFze9hds9Req3OfS+B+dv4qw= +github.com/libp2p/go-libp2p-yamux v0.2.5/go.mod h1:Zpgj6arbyQrmZ3wxSZxfBmbdnWtbZ48OpsfmQVTErwA= +github.com/libp2p/go-libp2p-yamux v0.2.7 h1:vzKu0NVtxvEIDGCv6mjKRcK0gipSgaXmJZ6jFv0d/dk= +github.com/libp2p/go-libp2p-yamux v0.2.7/go.mod h1:X28ENrBMU/nm4I3Nx4sZ4dgjZ6VhLEn0XhIoZ5viCwU= +github.com/libp2p/go-maddr-filter v0.0.1/go.mod h1:6eT12kSQMA9x2pvFQa+xesMKUBlj9VImZbj3B9FBH/Q= +github.com/libp2p/go-maddr-filter v0.0.4/go.mod h1:6eT12kSQMA9x2pvFQa+xesMKUBlj9VImZbj3B9FBH/Q= +github.com/libp2p/go-maddr-filter v0.0.5 h1:CW3AgbMO6vUvT4kf87y4N+0P8KUl2aqLYhrGyDUbLSg= +github.com/libp2p/go-maddr-filter v0.0.5/go.mod h1:Jk+36PMfIqCJhAnaASRH83bdAvfDRp/w6ENFaC9bG+M= +github.com/libp2p/go-mplex v0.0.1/go.mod h1:pK5yMLmOoBR1pNCqDlA2GQrdAVTMkqFalaTWe7l4Yd0= +github.com/libp2p/go-mplex v0.0.3/go.mod h1:pK5yMLmOoBR1pNCqDlA2GQrdAVTMkqFalaTWe7l4Yd0= +github.com/libp2p/go-mplex v0.0.4/go.mod h1:pK5yMLmOoBR1pNCqDlA2GQrdAVTMkqFalaTWe7l4Yd0= +github.com/libp2p/go-mplex v0.1.0/go.mod h1:SXgmdki2kwCUlCCbfGLEgHjC4pFqhTp0ZoV6aiKgxDU= +github.com/libp2p/go-mplex v0.1.1/go.mod h1:Xgz2RDCi3co0LeZfgjm4OgUF15+sVR8SRcu3SFXI1lk= +github.com/libp2p/go-mplex v0.1.2 h1:qOg1s+WdGLlpkrczDqmhYzyk3vCfsQ8+RxRTQjOZWwI= +github.com/libp2p/go-mplex v0.1.2/go.mod h1:Xgz2RDCi3co0LeZfgjm4OgUF15+sVR8SRcu3SFXI1lk= +github.com/libp2p/go-msgio v0.0.1/go.mod h1:63lBBgOTDKQL6EWazRMCwXsEeEeK9O2Cd+0+6OOuipQ= +github.com/libp2p/go-msgio v0.0.2/go.mod h1:63lBBgOTDKQL6EWazRMCwXsEeEeK9O2Cd+0+6OOuipQ= +github.com/libp2p/go-msgio v0.0.3/go.mod h1:63lBBgOTDKQL6EWazRMCwXsEeEeK9O2Cd+0+6OOuipQ= +github.com/libp2p/go-msgio v0.0.4 h1:agEFehY3zWJFUHK6SEMR7UYmk2z6kC3oeCM7ybLhguA= +github.com/libp2p/go-msgio v0.0.4/go.mod h1:63lBBgOTDKQL6EWazRMCwXsEeEeK9O2Cd+0+6OOuipQ= +github.com/libp2p/go-nat v0.0.3/go.mod h1:88nUEt0k0JD45Bk93NIwDqjlhiOwOoV36GchpcVc1yI= +github.com/libp2p/go-nat v0.0.4/go.mod h1:Nmw50VAvKuk38jUBcmNh6p9lUJLoODbJRvYAa/+KSDo= +github.com/libp2p/go-nat v0.0.5 h1:qxnwkco8RLKqVh1NmjQ+tJ8p8khNLFxuElYG/TwqW4Q= +github.com/libp2p/go-nat v0.0.5/go.mod h1:B7NxsVNPZmRLvMOwiEO1scOSyjA56zxYAGv1yQgRkEU= +github.com/libp2p/go-netroute v0.1.2 h1:UHhB35chwgvcRI392znJA3RCBtZ3MpE3ahNCN5MR4Xg= +github.com/libp2p/go-netroute v0.1.2/go.mod h1:jZLDV+1PE8y5XxBySEBgbuVAXbhtuHSdmLPL2n9MKbk= +github.com/libp2p/go-openssl v0.0.2/go.mod h1:v8Zw2ijCSWBQi8Pq5GAixw6DbFfa9u6VIYDXnvOXkc0= +github.com/libp2p/go-openssl v0.0.3/go.mod h1:unDrJpgy3oFr+rqXsarWifmJuNnJR4chtO1HmaZjggc= +github.com/libp2p/go-openssl v0.0.4 h1:d27YZvLoTyMhIN4njrkr8zMDOM4lfpHIp6A+TK9fovg= +github.com/libp2p/go-openssl v0.0.4/go.mod h1:unDrJpgy3oFr+rqXsarWifmJuNnJR4chtO1HmaZjggc= +github.com/libp2p/go-reuseport v0.0.1 h1:7PhkfH73VXfPJYKQ6JwS5I/eVcoyYi9IMNGc6FWpFLw= +github.com/libp2p/go-reuseport v0.0.1/go.mod h1:jn6RmB1ufnQwl0Q1f+YxAj8isJgDCQzaaxIFYDhcYEA= +github.com/libp2p/go-reuseport-transport v0.0.1/go.mod h1:YkbSDrvjUVDL6b8XqriyA20obEtsW9BLkuOUyQAOCbs= +github.com/libp2p/go-reuseport-transport v0.0.2/go.mod h1:YkbSDrvjUVDL6b8XqriyA20obEtsW9BLkuOUyQAOCbs= +github.com/libp2p/go-reuseport-transport v0.0.3 h1:zzOeXnTooCkRvoH+bSXEfXhn76+LAiwoneM0gnXjF2M= +github.com/libp2p/go-reuseport-transport v0.0.3/go.mod h1:Spv+MPft1exxARzP2Sruj2Wb5JSyHNncjf1Oi2dEbzM= +github.com/libp2p/go-sockaddr v0.0.2 h1:tCuXfpA9rq7llM/v834RKc/Xvovy/AqM9kHvTV/jY/Q= +github.com/libp2p/go-sockaddr v0.0.2/go.mod h1:syPvOmNs24S3dFVGJA1/mrqdeijPxLV2Le3BRLKd68k= +github.com/libp2p/go-sockaddr v0.1.0/go.mod h1:syPvOmNs24S3dFVGJA1/mrqdeijPxLV2Le3BRLKd68k= +github.com/libp2p/go-socket-activation v0.0.2/go.mod h1:KP44C+yZ7gA8sTxavgaD0b8vXVFJwam2CEW0s7+f094= +github.com/libp2p/go-stream-muxer v0.0.1/go.mod h1:bAo8x7YkSpadMTbtTaxGVHWUQsR/l5MEaHbKaliuT14= +github.com/libp2p/go-stream-muxer v0.1.0/go.mod h1:8JAVsjeRBCWwPoZeH0W1imLOcriqXJyFvB0mR4A04sQ= +github.com/libp2p/go-stream-muxer-multistream v0.1.1/go.mod h1:zmGdfkQ1AzOECIAcccoL8L//laqawOsO03zX8Sa+eGw= +github.com/libp2p/go-stream-muxer-multistream v0.2.0 h1:714bRJ4Zy9mdhyTLJ+ZKiROmAFwUHpeRidG+q7LTQOg= +github.com/libp2p/go-stream-muxer-multistream v0.2.0/go.mod h1:j9eyPol/LLRqT+GPLSxvimPhNph4sfYfMoDPd7HkzIc= +github.com/libp2p/go-stream-muxer-multistream v0.3.0 h1:TqnSHPJEIqDEO7h1wZZ0p3DXdvDSiLHQidKKUGZtiOY= +github.com/libp2p/go-stream-muxer-multistream v0.3.0/go.mod h1:yDh8abSIzmZtqtOt64gFJUXEryejzNb0lisTt+fAMJA= +github.com/libp2p/go-tcp-transport v0.0.1/go.mod h1:mnjg0o0O5TmXUaUIanYPUqkW4+u6mK0en8rlpA6BBTs= +github.com/libp2p/go-tcp-transport v0.0.4/go.mod h1:+E8HvC8ezEVOxIo3V5vCK9l1y/19K427vCzQ+xHKH/o= +github.com/libp2p/go-tcp-transport v0.1.0/go.mod h1:oJ8I5VXryj493DEJ7OsBieu8fcg2nHGctwtInJVpipc= +github.com/libp2p/go-tcp-transport v0.1.1/go.mod h1:3HzGvLbx6etZjnFlERyakbaYPdfjg2pWP97dFZworkY= +github.com/libp2p/go-tcp-transport v0.2.0 h1:YoThc549fzmNJIh7XjHVtMIFaEDRtIrtWciG5LyYAPo= +github.com/libp2p/go-tcp-transport v0.2.0/go.mod h1:vX2U0CnWimU4h0SGSEsg++AzvBcroCGYw28kh94oLe0= +github.com/libp2p/go-testutil v0.0.1/go.mod h1:iAcJc/DKJQanJ5ws2V+u5ywdL2n12X1WbbEG+Jjy69I= +github.com/libp2p/go-testutil v0.1.0/go.mod h1:81b2n5HypcVyrCg/MJx4Wgfp/VHojytjVe/gLzZ2Ehc= +github.com/libp2p/go-ws-transport v0.0.1/go.mod h1:p3bKjDWHEgtuKKj+2OdPYs5dAPIjtpQGHF2tJfGz7Ww= +github.com/libp2p/go-ws-transport v0.0.5/go.mod h1:Qbl4BxPfXXhhd/o0wcrgoaItHqA9tnZjoFZnxykuaXU= +github.com/libp2p/go-ws-transport v0.1.0/go.mod h1:rjw1MG1LU9YDC6gzmwObkPd/Sqwhw7yT74kj3raBFuo= +github.com/libp2p/go-ws-transport v0.2.0/go.mod h1:9BHJz/4Q5A9ludYWKoGCFC5gUElzlHoKzu0yY9p/klM= +github.com/libp2p/go-ws-transport v0.3.0 h1:mjo6pL5aVR9rCjl9wNq3DupbaQlyR61pzoOT2MdtxaA= +github.com/libp2p/go-ws-transport v0.3.0/go.mod h1:bpgTJmRZAvVHrgHybCVyqoBmyLQ1fiZuEaBYusP5zsk= +github.com/libp2p/go-ws-transport v0.3.1 h1:ZX5rWB8nhRRJVaPO6tmkGI/Xx8XNboYX20PW5hXIscw= +github.com/libp2p/go-ws-transport v0.3.1/go.mod h1:bpgTJmRZAvVHrgHybCVyqoBmyLQ1fiZuEaBYusP5zsk= +github.com/libp2p/go-yamux v1.2.1/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow= +github.com/libp2p/go-yamux v1.2.2/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow= +github.com/libp2p/go-yamux v1.2.3/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow= +github.com/libp2p/go-yamux v1.3.0/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow= +github.com/libp2p/go-yamux v1.3.3/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow= +github.com/libp2p/go-yamux v1.3.5 h1:ibuz4naPAully0pN6J/kmUARiqLpnDQIzI/8GCOrljg= +github.com/libp2p/go-yamux v1.3.5/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow= +github.com/lucas-clemente/quic-go v0.15.3 h1:i6n4Jr7673z9TlurAjc87+GlE/BN10++r9XZIPS9j6I= +github.com/lucas-clemente/quic-go v0.15.3/go.mod h1:oj40DjNLuNugvtXWg4PwaYgv7tAbzAabrT57CC69EhI= +github.com/lucas-clemente/quic-go v0.15.5 h1:2DR5qCVt4k1qnDmknf+idj1FDJIrkiDyS6a0uIR+UJY= +github.com/lucas-clemente/quic-go v0.15.5/go.mod h1:Myi1OyS0FOjL3not4BxT7KN29bRkcMUV5JVVFLKtDp8= +github.com/lunixbochs/vtclean v1.0.0/go.mod h1:pHhQNgMf3btfWnGBVipUOjRYhoOsdGqdm/+2c2E2WMI= +github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= +github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= +github.com/mailru/easyjson v0.0.0-20190312143242-1de009706dbe/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= +github.com/marten-seemann/qpack v0.1.0/go.mod h1:LFt1NU/Ptjip0C2CPkhimBz5CGE3WGDAUWqna+CNTrI= +github.com/marten-seemann/qtls v0.9.0 h1:8Zguhc72eS+DH5EAb0BpAPIy3HDXYcihQi4xoDZOnjQ= +github.com/marten-seemann/qtls v0.9.0/go.mod h1:T1MmAdDPyISzxlK6kjRr0pcZFBVd1OZbBb/j3cvzHhk= +github.com/marten-seemann/qtls v0.9.1 h1:O0YKQxNVPaiFgMng0suWEOY2Sb4LT2sRn9Qimq3Z1IQ= +github.com/marten-seemann/qtls v0.9.1/go.mod h1:T1MmAdDPyISzxlK6kjRr0pcZFBVd1OZbBb/j3cvzHhk= +github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= +github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ= +github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= +github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= +github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= +github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE= +github.com/mattn/go-runewidth v0.0.8/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= +github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= +github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE= +github.com/microcosm-cc/bluemonday v1.0.1/go.mod h1:hsXNsILzKxV+sX77C5b8FSuKF00vh2OMYv+xgHpAMF4= +github.com/miekg/dns v1.1.4/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= +github.com/miekg/dns v1.1.12/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= +github.com/miekg/dns v1.1.28 h1:gQhy5bsJa8zTlVI8lywCTZp1lguor+xevFoYlzeCTQY= +github.com/miekg/dns v1.1.28/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM= +github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g= +github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ= +github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16/go.mod h1:2FMWW+8GMoPweT6+pI63m9YE3Lmw4J71hV56Chs1E/U= +github.com/minio/sha256-simd v0.0.0-20190328051042-05b4dd3047e5/go.mod h1:2FMWW+8GMoPweT6+pI63m9YE3Lmw4J71hV56Chs1E/U= +github.com/minio/sha256-simd v0.1.0/go.mod h1:2FMWW+8GMoPweT6+pI63m9YE3Lmw4J71hV56Chs1E/U= +github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM= +github.com/minio/sha256-simd v0.1.1/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM= +github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= +github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8= +github.com/mr-tron/base58 v1.1.1/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8= +github.com/mr-tron/base58 v1.1.2/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= +github.com/mr-tron/base58 v1.1.3/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= +github.com/multiformats/go-base32 v0.0.3/go.mod h1:pLiuGC8y0QR3Ue4Zug5UzK9LjgbkL8NSQj0zQ5Nz/AA= +github.com/multiformats/go-multiaddr v0.0.1/go.mod h1:xKVEak1K9cS1VdmPZW3LSIb6lgmoS58qz/pzqmAxV44= +github.com/multiformats/go-multiaddr v0.0.2/go.mod h1:xKVEak1K9cS1VdmPZW3LSIb6lgmoS58qz/pzqmAxV44= +github.com/multiformats/go-multiaddr v0.0.4/go.mod h1:xKVEak1K9cS1VdmPZW3LSIb6lgmoS58qz/pzqmAxV44= +github.com/multiformats/go-multiaddr v0.1.0/go.mod h1:xKVEak1K9cS1VdmPZW3LSIb6lgmoS58qz/pzqmAxV44= +github.com/multiformats/go-multiaddr v0.1.1/go.mod h1:aMKBKNEYmzmDmxfX88/vz+J5IU55txyt0p4aiWVohjo= +github.com/multiformats/go-multiaddr v0.2.0/go.mod h1:0nO36NvPpyV4QzvTLi/lafl2y95ncPj0vFwVF6k6wJ4= +github.com/multiformats/go-multiaddr v0.2.1 h1:SgG/cw5vqyB5QQe5FPe2TqggU9WtrA9X4nZw7LlVqOI= +github.com/multiformats/go-multiaddr v0.2.1/go.mod h1:s/Apk6IyxfvMjDafnhJgJ3/46z7tZ04iMk5wP4QMGGE= +github.com/multiformats/go-multiaddr-dns v0.0.1/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q= +github.com/multiformats/go-multiaddr-dns v0.0.2/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q= +github.com/multiformats/go-multiaddr-dns v0.0.3/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q= +github.com/multiformats/go-multiaddr-dns v0.2.0/go.mod h1:TJ5pr5bBO7Y1B18djPuRsVkduhQH2YqYSbxWJzYGdK0= +github.com/multiformats/go-multiaddr-fmt v0.0.1/go.mod h1:aBYjqL4T/7j4Qx+R73XSv/8JsgnRFlf0w2KGLCmXl3Q= +github.com/multiformats/go-multiaddr-fmt v0.1.0/go.mod h1:hGtDIW4PU4BqJ50gW2quDuPVjyWNZxToGUh/HwTZYJo= +github.com/multiformats/go-multiaddr-net v0.0.1/go.mod h1:nw6HSxNmCIQH27XPGBuX+d1tnvM7ihcFwHMSstNAVUU= +github.com/multiformats/go-multiaddr-net v0.1.0/go.mod h1:5JNbcfBOP4dnhoZOv10JJVkJO0pCCEf8mTnipAo2UZQ= +github.com/multiformats/go-multiaddr-net v0.1.1/go.mod h1:5JNbcfBOP4dnhoZOv10JJVkJO0pCCEf8mTnipAo2UZQ= +github.com/multiformats/go-multiaddr-net v0.1.2/go.mod h1:QsWt3XK/3hwvNxZJp92iMQKME1qHfpYmyIjFVsSOY6Y= +github.com/multiformats/go-multiaddr-net v0.1.3/go.mod h1:ilNnaM9HbmVFqsb/qcNysjCu4PVONlrBZpHIrw/qQuA= +github.com/multiformats/go-multiaddr-net v0.1.4 h1:g6gwydsfADqFvrHoMkS0n9Ok9CG6F7ytOH/bJDkhIOY= +github.com/multiformats/go-multiaddr-net v0.1.4/go.mod h1:ilNnaM9HbmVFqsb/qcNysjCu4PVONlrBZpHIrw/qQuA= +github.com/multiformats/go-multibase v0.0.1/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs= +github.com/multiformats/go-multibase v0.0.2 h1:2pAgScmS1g9XjH7EtAfNhTuyrWYEWcxy0G5Wo85hWDA= +github.com/multiformats/go-multibase v0.0.2/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs= +github.com/multiformats/go-multihash v0.0.1/go.mod h1:w/5tugSrLEbWqlcgJabL3oHFKTwfvkofsjW2Qa1ct4U= +github.com/multiformats/go-multihash v0.0.5/go.mod h1:lt/HCbqlQwlPBz7lv0sQCdtfcMtlJvakRUn/0Ual8po= +github.com/multiformats/go-multihash v0.0.6/go.mod h1:XuKXPp8VHcTygube3OWZC+aZrA+H1IhmjoCDtJc7PXM= +github.com/multiformats/go-multihash v0.0.7/go.mod h1:XuKXPp8VHcTygube3OWZC+aZrA+H1IhmjoCDtJc7PXM= +github.com/multiformats/go-multihash v0.0.8/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew= +github.com/multiformats/go-multihash v0.0.9/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew= +github.com/multiformats/go-multihash v0.0.10/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew= +github.com/multiformats/go-multihash v0.0.13 h1:06x+mk/zj1FoMsgNejLpy6QTvJqlSt/BhLEy87zidlc= +github.com/multiformats/go-multihash v0.0.13/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc= +github.com/multiformats/go-multistream v0.0.1/go.mod h1:fJTiDfXJVmItycydCnNx4+wSzZ5NwG2FEVAI30fiovg= +github.com/multiformats/go-multistream v0.0.4/go.mod h1:fJTiDfXJVmItycydCnNx4+wSzZ5NwG2FEVAI30fiovg= +github.com/multiformats/go-multistream v0.1.0/go.mod h1:fJTiDfXJVmItycydCnNx4+wSzZ5NwG2FEVAI30fiovg= +github.com/multiformats/go-multistream v0.1.1 h1:JlAdpIFhBhGRLxe9W6Om0w++Gd6KMWoFPZL/dEnm9nI= +github.com/multiformats/go-multistream v0.1.1/go.mod h1:KmHZ40hzVxiaiwlj3MEbYgK9JFk2/9UktWZAF54Du38= +github.com/multiformats/go-varint v0.0.1/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE= +github.com/multiformats/go-varint v0.0.2/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE= +github.com/multiformats/go-varint v0.0.5 h1:XVZwSo04Cs3j/jS0uAEPpT3JY6DzMcVLLoWOSnCxOjg= +github.com/multiformats/go-varint v0.0.5/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE= +github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= +github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJEU3ofeGjhHklVoIGuVj85JJwZ6kWPaJwCIxgnFmo= +github.com/neelance/sourcemap v0.0.0-20151028013722-8c68805598ab/go.mod h1:Qr6/a/Q4r9LP1IltGz7tA7iOK1WonHEYhu1HRBA7ZiM= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.11.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.12.0 h1:Iw5WCbBcaAAd0fpRb1c9r5YCylv4XDoCSigm1zLevwU= +github.com/onsi/ginkgo v1.12.0/go.mod h1:oUhWkIvk5aDxtKvDDuw8gItl8pKl42LzjC9KZE0HfGg= +github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= +github.com/onsi/gomega v1.8.1/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA= +github.com/onsi/gomega v1.9.0 h1:R1uwffexN6Pr340GtYRIdZmAiN4J+iw6WG4wog1DUXg= +github.com/onsi/gomega v1.9.0/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA= +github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= +github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= +github.com/openzipkin/zipkin-go v0.1.1/go.mod h1:NtoC/o8u3JlF1lSlyPNswIbeQH9bJTmOf0Erfk+hxe8= +github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= +github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/polydawn/refmt v0.0.0-20190221155625-df39d6c2d992/go.mod h1:uIp+gprXxxrWSjjklXD+mN4wed/tMfjMMmN/9+JsA9o= +github.com/polydawn/refmt v0.0.0-20190408063855-01bf1e26dd14 h1:2m16U/rLwVaRdz7ANkHtHTodP3zTP3N451MADg64x5k= +github.com/polydawn/refmt v0.0.0-20190408063855-01bf1e26dd14/go.mod h1:uIp+gprXxxrWSjjklXD+mN4wed/tMfjMMmN/9+JsA9o= +github.com/prometheus/client_golang v0.8.0/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= +github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= +github.com/prometheus/client_golang v0.9.2/go.mod h1:OsXs2jCmiKlQ1lTBmv21f2mNfw4xf/QclQDMrYNZzcM= +github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= +github.com/prometheus/client_golang v1.5.1/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU= +github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= +github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/common v0.0.0-20180801064454-c7de2306084e/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro= +github.com/prometheus/common v0.0.0-20181126121408-4724e9255275/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro= +github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= +github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4= +github.com/prometheus/procfs v0.0.0-20180725123919-05ee40e3a273/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= +github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= +github.com/prometheus/procfs v0.0.0-20181204211112-1dc9a6cbc91a/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= +github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= +github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A= +github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= +github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= +github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= +github.com/shurcooL/component v0.0.0-20170202220835-f88ec8f54cc4/go.mod h1:XhFIlyj5a1fBNx5aJTbKoIq0mNaPvOagO+HjB3EtxrY= +github.com/shurcooL/events v0.0.0-20181021180414-410e4ca65f48/go.mod h1:5u70Mqkb5O5cxEA8nxTsgrgLehJeAw6Oc4Ab1c/P1HM= +github.com/shurcooL/github_flavored_markdown v0.0.0-20181002035957-2122de532470/go.mod h1:2dOwnU2uBioM+SGy2aZoq1f/Sd1l9OkAeAUvjSyvgU0= +github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk= +github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ= +github.com/shurcooL/gofontwoff v0.0.0-20180329035133-29b52fc0a18d/go.mod h1:05UtEgK5zq39gLST6uB0cf3NEHjETfB4Fgr3Gx5R9Vw= +github.com/shurcooL/gopherjslib v0.0.0-20160914041154-feb6d3990c2c/go.mod h1:8d3azKNyqcHP1GaQE/c6dDgjkgSx2BZ4IoEi4F1reUI= +github.com/shurcooL/highlight_diff v0.0.0-20170515013008-09bb4053de1b/go.mod h1:ZpfEhSmds4ytuByIcDnOLkTHGUI6KNqRNPDLHDk+mUU= +github.com/shurcooL/highlight_go v0.0.0-20181028180052-98c3abbbae20/go.mod h1:UDKB5a1T23gOMUJrI+uSuH0VRDStOiUVSjBTRDVBVag= +github.com/shurcooL/home v0.0.0-20181020052607-80b7ffcb30f9/go.mod h1:+rgNQw2P9ARFAs37qieuu7ohDNQ3gds9msbT2yn85sg= +github.com/shurcooL/htmlg v0.0.0-20170918183704-d01228ac9e50/go.mod h1:zPn1wHpTIePGnXSHpsVPWEktKXHr6+SS6x/IKRb7cpw= +github.com/shurcooL/httperror v0.0.0-20170206035902-86b7830d14cc/go.mod h1:aYMfkZ6DWSJPJ6c4Wwz3QtW22G7mf/PEgaB9k/ik5+Y= +github.com/shurcooL/httpfs v0.0.0-20171119174359-809beceb2371/go.mod h1:ZY1cvUeJuFPAdZ/B6v7RHavJWZn2YPVFQ1OSXhCGOkg= +github.com/shurcooL/httpgzip v0.0.0-20180522190206-b1c53ac65af9/go.mod h1:919LwcH0M7/W4fcZ0/jy0qGght1GIhqyS/EgWGH2j5Q= +github.com/shurcooL/issues v0.0.0-20181008053335-6292fdc1e191/go.mod h1:e2qWDig5bLteJ4fwvDAc2NHzqFEthkqn7aOZAOpj+PQ= +github.com/shurcooL/issuesapp v0.0.0-20180602232740-048589ce2241/go.mod h1:NPpHK2TI7iSaM0buivtFUc9offApnI0Alt/K8hcHy0I= +github.com/shurcooL/notifications v0.0.0-20181007000457-627ab5aea122/go.mod h1:b5uSkrEVM1jQUspwbixRBhaIjIzL2xazXp6kntxYle0= +github.com/shurcooL/octicon v0.0.0-20181028054416-fa4f57f9efb2/go.mod h1:eWdoE5JD4R5UVWDucdOPg1g2fqQRq78IQa9zlOV1vpQ= +github.com/shurcooL/reactions v0.0.0-20181006231557-f2e0b4ca5b82/go.mod h1:TCR1lToEk4d2s07G3XGfz2QrgHXg4RJBvjrOozvoWfk= +github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= +github.com/shurcooL/users v0.0.0-20180125191416-49c67e49c537/go.mod h1:QJTqeLYEDaXHZDBsXlPCDqdhQuJkuw4NOtaxYe3xii4= +github.com/shurcooL/webdavfs v0.0.0-20170829043945-18c3829fa133/go.mod h1:hKmq5kWdCj2z2KEozexVbfEZIWiTjhE0+UjmZgPqehw= +github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= +github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= +github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= +github.com/smartystreets/assertions v1.0.0 h1:UVQPSSmc3qtTi+zPPkCXvZX9VvW/xT/NsRvKfwY81a8= +github.com/smartystreets/assertions v1.0.0/go.mod h1:kHHU4qYBaI3q23Pp3VPrmWhuIUrLW/7eUrw0BU5VaoM= +github.com/smartystreets/goconvey v0.0.0-20190222223459-a17d461953aa/go.mod h1:2RVY1rIf+2J2o/IM9+vPq9RzmHDSseB7FoXiSNIUsoU= +github.com/smartystreets/goconvey v0.0.0-20190330032615-68dc04aab96a/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= +github.com/smartystreets/goconvey v0.0.0-20190710185942-9d28bd7c0945 h1:N8Bg45zpk/UcpNGnfJt2y/3lRWASHNTUET8owPYCgYI= +github.com/smartystreets/goconvey v0.0.0-20190710185942-9d28bd7c0945/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= +github.com/smola/gocompat v0.2.0/go.mod h1:1B0MlxbmoZNo3h8guHp8HztB3BSYR5itql9qtVc0ypY= +github.com/sourcegraph/annotate v0.0.0-20160123013949-f4cad6c6324d/go.mod h1:UdhH50NIW0fCiwBSr0co2m7BnFLdv4fQTgdqdJTHFeE= +github.com/sourcegraph/syntaxhighlight v0.0.0-20170531221838-bd320f5d308e/go.mod h1:HuIsMU8RRBOtsCgI77wP899iHVBQpCmg4ErYMZB+2IA= +github.com/spacemonkeygo/openssl v0.0.0-20181017203307-c2dcc5cca94a/go.mod h1:7AyxJNCJ7SBZ1MfVQCWD6Uqo2oubI2Eq2y2eqf+A5r0= +github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572 h1:RC6RW7j+1+HkWaX/Yh71Ee5ZHaHYt7ZP4sQgUrm6cDU= +github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572/go.mod h1:w0SWMsp6j9O/dk4/ZpIhL+3CkG8ofA2vuv7k+ltqUMc= +github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI= +github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= +github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= +github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= +github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= +github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s= +github.com/src-d/envconfig v1.0.0/go.mod h1:Q9YQZ7BKITldTBnoxsE5gOeB5y66RyPXeue/R4aaNBc= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4= +github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ= +github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA= +github.com/texttheater/golang-levenshtein v0.0.0-20180516184445-d188e65d659e/go.mod h1:XDKHRm5ThF8YJjx001LtgelzsoaEcvnA7lVWz9EeX3g= +github.com/tv42/httpunix v0.0.0-20191220191345-2ba4b9c3382c h1:u6SKchux2yDvFQnDHS3lPnIRmfVJ5Sxy3ao2SIdysLQ= +github.com/tv42/httpunix v0.0.0-20191220191345-2ba4b9c3382c/go.mod h1:hzIxponao9Kjc7aWznkXaL4U4TWaDSs8zcsY4Ka08nM= +github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0= +github.com/viant/assertly v0.4.8/go.mod h1:aGifi++jvCrUaklKEKT0BU95igDNaqkvz+49uaYMPRU= +github.com/viant/toolbox v0.24.0/go.mod h1:OxMCG57V0PXuIP2HNQrtJf2CjqdmbrOx5EkMILuUhzM= +github.com/wangjia184/sortedset v0.0.0-20160527075905-f5d03557ba30/go.mod h1:YkocrP2K2tcw938x9gCOmT5G5eCD6jsTz0SZuyAqwIE= +github.com/warpfork/go-wish v0.0.0-20180510122957-5ad1f5abf436/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw= +github.com/warpfork/go-wish v0.0.0-20190328234359-8b3e70f8e830 h1:8kxMKmKzXXL4Ru1nyhvdms/JjWt+3YLpvRb/bAjO/y0= +github.com/warpfork/go-wish v0.0.0-20190328234359-8b3e70f8e830/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw= +github.com/whyrusleeping/base32 v0.0.0-20170828182744-c30ac30633cc/go.mod h1:r45hJU7yEoA81k6MWNhpMj/kms0n14dkzkxYHoB96UM= +github.com/whyrusleeping/cbor-gen v0.0.0-20200123233031-1cdf64d27158 h1:WXhVOwj2USAXB5oMDwRl3piOux2XMV9TANaYxXHdkoE= +github.com/whyrusleeping/cbor-gen v0.0.0-20200123233031-1cdf64d27158/go.mod h1:Xj/M2wWU+QdTdRbu/L/1dIZY8/Wb2K9pAhtroQuxJJI= +github.com/whyrusleeping/chunker v0.0.0-20181014151217-fe64bd25879f/go.mod h1:p9UJB6dDgdPgMJZs7UjUOdulKyRr9fqkS+6JKAInPy8= +github.com/whyrusleeping/go-keyspace v0.0.0-20160322163242-5b898ac5add1/go.mod h1:8UvriyWtv5Q5EOgjHaSseUEdkQfvwFv1I/In/O2M9gc= +github.com/whyrusleeping/go-logging v0.0.0-20170515211332-0457bb6b88fc/go.mod h1:bopw91TMyo8J3tvftk8xmU2kPmlrt4nScJQZU2hE5EM= +github.com/whyrusleeping/go-logging v0.0.1/go.mod h1:lDPYj54zutzG1XYfHAhcc7oNXEburHQBn+Iqd4yS4vE= +github.com/whyrusleeping/go-notifier v0.0.0-20170827234753-097c5d47330f/go.mod h1:cZNvX9cFybI01GriPRMXDtczuvUhgbcYr9iCGaNlRv8= +github.com/whyrusleeping/go-smux-multiplex v3.0.16+incompatible/go.mod h1:34LEDbeKFZInPUrAG+bjuJmUXONGdEFW7XL0SpTY1y4= +github.com/whyrusleeping/go-smux-multistream v2.0.2+incompatible/go.mod h1:dRWHHvc4HDQSHh9gbKEBbUZ+f2Q8iZTPG3UOGYODxSQ= +github.com/whyrusleeping/go-smux-yamux v2.0.8+incompatible/go.mod h1:6qHUzBXUbB9MXmw3AUdB52L8sEb/hScCqOdW2kj/wuI= +github.com/whyrusleeping/go-smux-yamux v2.0.9+incompatible/go.mod h1:6qHUzBXUbB9MXmw3AUdB52L8sEb/hScCqOdW2kj/wuI= +github.com/whyrusleeping/go-sysinfo v0.0.0-20190219211824-4a357d4b90b1/go.mod h1:tKH72zYNt/exx6/5IQO6L9LoQ0rEjd5SbbWaDTs9Zso= +github.com/whyrusleeping/mafmt v1.2.8/go.mod h1:faQJFPbLSxzD9xpA02ttW/tS9vZykNvXwGvqIpk20FA= +github.com/whyrusleeping/mdns v0.0.0-20180901202407-ef14215e6b30/go.mod h1:j4l84WPFclQPj320J9gp0XwNKBb3U0zt5CBqjPp22G4= +github.com/whyrusleeping/mdns v0.0.0-20190826153040-b9b60ed33aa9 h1:Y1/FEOpaCpD21WxrmfeIYCFPuVPRCY2XZTWzTNHGw30= +github.com/whyrusleeping/mdns v0.0.0-20190826153040-b9b60ed33aa9/go.mod h1:j4l84WPFclQPj320J9gp0XwNKBb3U0zt5CBqjPp22G4= +github.com/whyrusleeping/multiaddr-filter v0.0.0-20160516205228-e903e4adabd7 h1:E9S12nwJwEOXe2d6gT6qxdvqMnNq+VnSsKPgm2ZZNds= +github.com/whyrusleeping/multiaddr-filter v0.0.0-20160516205228-e903e4adabd7/go.mod h1:X2c0RVCI1eSUFI8eLcY3c0423ykwiUdxLJtkDvruhjI= +github.com/whyrusleeping/tar-utils v0.0.0-20180509141711-8c6c8ba81d5c/go.mod h1:xxcJeBb7SIUl/Wzkz1eVKJE/CB34YNrqX2TQI6jY9zs= +github.com/whyrusleeping/timecache v0.0.0-20160911033111-cfcb2f1abfee/go.mod h1:m2aV4LZI4Aez7dP5PMyVKEHhUyEJ/RjmPEDOpDvudHg= +github.com/whyrusleeping/yamux v1.1.5/go.mod h1:E8LnQQ8HKx5KD29HZFUwM1PxCOdPRzGwur1mcYhXcD8= +github.com/x-cray/logrus-prefixed-formatter v0.5.2/go.mod h1:2duySbKsL6M18s5GU7VPsoEPHyzalCE06qoARUCeBBE= +github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= +go.opencensus.io v0.18.0/go.mod h1:vKdFvxhtzZ9onBp9VKHK8z/sRpBMnKAsufL7wlDrCOA= +go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= +go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= +go.opencensus.io v0.22.1/go.mod h1:Ap50jQcDJrx6rB6VgeeFPtuPIf3wMRvRfrfYDO6+BmA= +go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.opencensus.io v0.22.3 h1:8sGtKOrtQqkN1bp2AtX+misvLIlOmsEsNd+9NIcPEm8= +go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= +go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= +go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= +go.uber.org/atomic v1.6.0 h1:Ezj3JGmsOnG1MoRWQkPBsKLe9DwWD9QeXzTRzzldNVk= +go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= +go.uber.org/dig v1.9.0 h1:pJTDXKEhRqBI8W7rU7kwT5EgyRZuSMVSFcZolOvKK9U= +go.uber.org/dig v1.9.0/go.mod h1:X34SnWGr8Fyla9zQNO2GSO2D+TIuqB14OS8JhYocIyw= +go.uber.org/fx v1.11.0 h1:WTxcE9VicMCGSB//JfMtpD9XP500wJx6w8lYEcsdPQk= +go.uber.org/fx v1.11.0/go.mod h1:egT3Kyg1JFYQkvKLZ3EsykxkNrZxgXS+gKoKo7abERY= +go.uber.org/fx v1.12.0 h1:+1+3Cz9M0dFMPy9SW9XUIUHye8bnPUm7q7DroNGWYG4= +go.uber.org/fx v1.12.0/go.mod h1:egT3Kyg1JFYQkvKLZ3EsykxkNrZxgXS+gKoKo7abERY= +go.uber.org/goleak v0.10.0/go.mod h1:VCZuO8V8mFPlL0F5J5GK1rtHV3DrFcQ1R8ryq7FK0aI= +go.uber.org/goleak v1.0.0 h1:qsup4IcBdlmsnGfqyLl4Ntn3C2XCCuKAE7DwHpScyUo= +go.uber.org/goleak v1.0.0/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= +go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= +go.uber.org/multierr v1.4.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= +go.uber.org/multierr v1.5.0 h1:KCa4XfM8CWFCpxXRGok+Q0SS/0XBhMDbHHGABQLvD2A= +go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU= +go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA= +go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= +go.uber.org/zap v1.14.1 h1:nYDKopTbvAPq/NrUVZwT15y2lpROBiLLyoRTbXOYWOo= +go.uber.org/zap v1.14.1/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc= +go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE= +go4.org v0.0.0-20200104003542-c7e774b10ea0 h1:M6XsnQeLwG+rHQ+/rrGh3puBI3WZEy9TBWmf2H+enQA= +go4.org v0.0.0-20200104003542-c7e774b10ea0/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE= +golang.org/x/build v0.0.0-20190111050920-041ab4dc3f9d/go.mod h1:OWs+y06UdEOHN4y+MfF/py+xQ/tYqIWW03b70/CG9Rw= +golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190225124518-7f87c0fbb88b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190228161510-8dd112bcdc25/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190313024323-a1f597ede03a/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190513172903-22d7a77e9e5f/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190618222545-ea8f1a30c443/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20200115085410-6d4e4cb37c7d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20200406173513-056763e48d71 h1:DOmugCavvUtnUD114C1Wh+UgTgQZ4pMLzXxi1pSt+/Y= +golang.org/x/crypto v0.0.0-20200406173513-056763e48d71/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5 h1:Q7tZBpemrlsc2I7IyODzhtallWRSm4Q0d09pL6XbQtU= +golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= +golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= +golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/net v0.0.0-20180524181706-dfa909b99c79/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181011144130-49bb7cea24b1/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181029044818-c44066c5c816/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181106065722-10aee1819953/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190227160552-c95aed5357e7/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190228165749-92fc7df08ae7/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190611141213-3f473d35a33a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20190923162816-aa69164e4478 h1:l5EDrHhldLYb3ZRHDUhXF7Om7MvYXnkV9/iQNo1lX6g= +golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= +golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +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= +golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/perf v0.0.0-20180704124530-6e6d33e29852/go.mod h1:JLpeXjPJfIyPr5TlbXLkXWLhP8nz10XfvxElABhCtcw= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181029174526-d69651ed3497/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190219092855-153ac476189d/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190228124157-a34e9553db1e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190302025703-b6889370fb10/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190316082340-a2f829d7f35f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190405154228-4b34438f7a67/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190524122548-abf6ff778158/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190524152521-dbbf3f1254d4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190526052359-791d8a0f4d09/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190610200419-93c9922d18ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191210023423-ac6580df4449/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200408040146-ea54a3c99b9b h1:h03Ur1RlPrGTjua4koYdpGl8W0eYo8p1uI9w7RPlkdk= +golang.org/x/sys v0.0.0-20200408040146-ea54a3c99b9b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200413165638-669c56c373c4 h1:opSr2sbRXk5X5/givKrrKj9HXxFpW2sdCiP8MJSKLQY= +golang.org/x/sys v0.0.0-20200413165638-669c56c373c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +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= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +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/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20181030000716-a0a13e073c7b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20181130052023-1c3d964395ce/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191030062658-86caa796c7ab/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191114200427-caa0b0f7d508/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191216052735-49a3e744a425 h1:VvQyQJN0tSuecqgcIxMWnnfG5kSmgy9KZR9sW3W5QeA= +golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +google.golang.org/api v0.0.0-20180910000450-7ca32eb868bf/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0= +google.golang.org/api v0.0.0-20181030000543-1d582fd0359e/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0= +google.golang.org/api v0.1.0/go.mod h1:UGEZY7KEX120AnNLIHFMKIo4obdJhkp2tPbaPlQx13Y= +google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= +google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.3.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20181029155118-b69ba1387ce2/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/genproto v0.0.0-20181202183823-bd91e49a0898/go.mod h1:7Ep/1NZk928CDR8SjdVbjWNpdIf6nzjE3BTgJDr2Atg= +google.golang.org/genproto v0.0.0-20190306203927-b5d61aea6440/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= +google.golang.org/grpc v1.16.0/go.mod h1:0JHn/cJsOMiMfNA9+DeHDlAU7KAAB5GDlYFpa9MZMio= +google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= +gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo= +gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/cheggaaa/pb.v1 v1.0.28/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw= +gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= +gopkg.in/src-d/go-cli.v0 v0.0.0-20181105080154-d492247bbc0d/go.mod h1:z+K8VcOYVYcSwSjGebuDL6176A1XskgbtNl64NSg+n8= +gopkg.in/src-d/go-log.v1 v1.0.1/go.mod h1:GN34hKP0g305ysm2/hctJ0Y8nWP3zxXXJ8GFabTyABE= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.5 h1:ymVxjfMaHvXD8RqPRmzHHsB3VvucivSkIAvJFDI5O3c= +gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o= +honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= +rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= +rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= +sourcegraph.com/sourcegraph/go-diff v0.5.0/go.mod h1:kuch7UrkMzY0X+p9CRK03kfuPQ2zzQcaEFbx8wA8rck= +sourcegraph.com/sqs/pbtypes v0.0.0-20180604144634-d3ebe8f20ae4/go.mod h1:ketZ/q3QxT9HOBeFhu6RdvsftgpsbFHBF5Cas6cDKZ0= diff --git a/docs/examples/go-ipfs-as-a-library/main.go b/docs/examples/go-ipfs-as-a-library/main.go index cc390ecebf7..f07398c307d 100644 --- a/docs/examples/go-ipfs-as-a-library/main.go +++ b/docs/examples/go-ipfs-as-a-library/main.go @@ -300,12 +300,17 @@ func main() { // IPFS Cluster Pinning nodes "/ip4/138.201.67.219/tcp/4001/p2p/QmUd6zHcbkbcs7SMxwLs48qZVX3vpcM8errYS7xEczwRMA", + "/ip4/138.201.67.219/udp/4001/quic/p2p/QmUd6zHcbkbcs7SMxwLs48qZVX3vpcM8errYS7xEczwRMA", "/ip4/138.201.67.220/tcp/4001/p2p/QmNSYxZAiJHeLdkBg38roksAR9So7Y5eojks1yjEcUtZ7i", + "/ip4/138.201.67.220/udp/4001/quic/p2p/QmNSYxZAiJHeLdkBg38roksAR9So7Y5eojks1yjEcUtZ7i", "/ip4/138.201.68.74/tcp/4001/p2p/QmdnXwLrC8p1ueiq2Qya8joNvk3TVVDAut7PrikmZwubtR", + "/ip4/138.201.68.74/udp/4001/quic/p2p/QmdnXwLrC8p1ueiq2Qya8joNvk3TVVDAut7PrikmZwubtR", "/ip4/94.130.135.167/tcp/4001/p2p/QmUEMvxS2e7iDrereVYc5SWPauXPyNwxcy9BXZrC1QTcHE", + "/ip4/94.130.135.167/udp/4001/quic/p2p/QmUEMvxS2e7iDrereVYc5SWPauXPyNwxcy9BXZrC1QTcHE", // You can add more nodes here, for example, another IPFS node you might have running locally, mine was: // "/ip4/127.0.0.1/tcp/4010/p2p/QmZp2fhDLxjYue2RiUvLwT9MWdnbDxam32qYFnGmxZDh5L", + // "/ip4/127.0.0.1/udp/4010/quic/p2p/QmZp2fhDLxjYue2RiUvLwT9MWdnbDxam32qYFnGmxZDh5L", } go connectToPeers(ctx, ipfs, bootstrapNodes) diff --git a/docs/examples/library-experimental-features/README.md b/docs/examples/library-experimental-features/README.md index 6387f3618a9..a351706951b 100644 --- a/docs/examples/library-experimental-features/README.md +++ b/docs/examples/library-experimental-features/README.md @@ -56,8 +56,6 @@ func createTempRepo(ctx context.Context) (string, error) { cfg.Experimental.Libp2pStreamMounting = true // https://github.com/ipfs/go-ipfs/blob/master/docs/experimental-features.md#p2p-http-proxy cfg.Experimental.P2pHttpProxy = true - // https://github.com/ipfs/go-ipfs/blob/master/docs/experimental-features.md#quic - cfg.Experimental.QUIC = true // https://github.com/ipfs/go-ipfs/blob/master/docs/experimental-features.md#strategic-providing cfg.Experimental.StrategicProviding = true diff --git a/docs/experimental-features.md b/docs/experimental-features.md index 3c86d55bb53..725ccd46251 100644 --- a/docs/experimental-features.md +++ b/docs/experimental-features.md @@ -13,23 +13,19 @@ feature, you MUST please make a PR updating this document, and link the PR in the above issue. - [ipfs pubsub](#ipfs-pubsub) -- [Client mode DHT routing](#client-mode-dht-routing) -- [go-multiplex stream muxer](#go-multiplex-stream-muxer) - [Raw leaves for unixfs files](#raw-leaves-for-unixfs-files) - [ipfs filestore](#ipfs-filestore) - [ipfs urlstore](#ipfs-urlstore) - [Private Networks](#private-networks) - [ipfs p2p](#ipfs-p2p) - [p2p http proxy](#p2p-http-proxy) -- [Circuit Relay](#circuit-relay) - [Plugins](#plugins) - [Directory Sharding / HAMT](#directory-sharding--hamt) - [IPNS PubSub](#ipns-pubsub) -- [QUIC](#quic) - [AutoRelay](#autorelay) -- [TLS 1.3 Handshake](#tls-13-as-default-handshake-protocol) - [Strategic Providing](#strategic-providing) -- [Graphsync](graphsync) +- [Graphsync](#graphsync) +- [Noise](#noise) --- @@ -48,35 +44,12 @@ Candidate, disabled by default but will be enabled by default in 0.6.0. run your daemon with the `--enable-pubsub-experiment` flag. Then use the `ipfs pubsub` commands. -### gossipsub - -Gossipsub is a new, experimental routing protocol for pubsub that -should waste less bandwidth than floodsub, the current pubsub -protocol. It's backward compatible with floodsub so enabling this -feature shouldn't break compatibility with existing IPFS nodes. - -You can enable gossipsub via configuration: -`ipfs config Pubsub.Router gossipsub` - -### Message Signing - -As of 0.4.18, go-ipfs signs all pubsub messages by default. For now, it doesn't -*reject* unsigned messages but it will in the future. - -You can turn off message signing (not recommended unless you're using a private -network) by running: -`ipfs config Pubsub.DisableSigning true` - -You can turn on strict signature verification (require that all messages be -signed) by running: -`ipfs config Pubsub.StrictSignatureVerification true` - -(this last option will be set to true by default and eventually removed entirely) +Configuration documentation can be found in [./config.md]() ### Road to being a real feature -- [ ] Needs more people to use and report on how well it works -- [ ] Needs authenticating modes to be implemented -- [ ] needs performance analyses to be done + +- [ ] Needs to not impact peers who don't use pubsub: + https://github.com/libp2p/go-libp2p-pubsub/issues/332 ## Raw Leaves for unixfs files @@ -454,7 +427,14 @@ ipfs config --json Experimental.ShardingEnabled true ### In Version -0.4.14 +0.4.14 : + - Introduced + +0.5.0 : + - No longer needs to use the DHT for the first resolution + - When discovering PubSub peers via the DHT, the DHT key is different from previous versions + - This leads to 0.5 IPNS pubsub peers and 0.4 IPNS pubsub peers not being able to find each other in the DHT + - Robustness improvements ### State @@ -466,10 +446,14 @@ When it is enabled: - IPNS publishers push records to a name-specific pubsub topic, in addition to publishing to the DHT. - IPNS resolvers subscribe to the name-specific topic on first - resolution and receive subsequently published records through pubsub in real time. This makes subsequent resolutions instant, as they are resolved through the local cache. Note that the initial resolution still goes through the DHT, as there is no message history in pubsub. + resolution and receive subsequently published records through pubsub in real time. + This makes subsequent resolutions instant, as they are resolved through the local cache. Both the publisher and the resolver nodes need to have the feature enabled for it to work effectively. +Note: While IPNS pubsub has been available since 0.4.14, it received major changes in 0.5.0. +Users interested in this feature should upgrade to at least 0.5.0 + ### How to enable run your daemon with the `--enable-namesys-pubsub` flag; enables pubsub. @@ -477,38 +461,7 @@ run your daemon with the `--enable-namesys-pubsub` flag; enables pubsub. ### Road to being a real feature - [ ] Needs more people to use and report on how well it works -- [ ] Add a mechanism for last record distribution on subscription, - so that we don't have to hit the DHT for the initial resolution. - Alternatively, we could republish the last record periodically. - -## QUIC - -### In Version - -0.4.18 - -### State - -Candidate, disabled by default but it will be enabled by default in 0.6.0. - -### How to enable - -Modify your ipfs config: - -``` -ipfs config --json Experimental.QUIC true -``` - -For listening on a QUIC address, add it to the swarm addresses, e.g. `/ip4/0.0.0.0/udp/4001/quic`. - - -### Road to being a real feature - -- [ ] The IETF QUIC specification needs to be finalized. -- [ ] Make sure QUIC connections work reliably -- [ ] Make sure QUIC connection offer equal or better performance than TCP connections on real-world networks -- [ ] Finalize libp2p-TLS handshake spec. - +- [ ] Pubsub enabled as a real feature ## AutoRelay @@ -586,3 +539,31 @@ ipfs config --json Experimental.GraphsyncEnabled true ### Road to being a real feature - [ ] We need to confirm that it can't be used to DoS a node. The server-side logic for GraphSync is quite complex and, if we're not careful, the server might end up performing unbounded work when responding to a malicious request. + +## Noise + +### State + +Experimental, enabled by default + +[Noise](https://github.com/libp2p/specs/tree/master/noise) libp2p transport based on the [Noise Protocol Framework](https://noiseprotocol.org/noise.html). While TLS remains the default transport in go-ipfs, Noise is easier to implement and will thus serve as the "interop" transport between IPFS and libp2p implementations, eventually replacing SECIO. + +### How to enable + +While the Noise transport is now shipped and enabled by default in go-ipfs, it won't be used by default for most connections because TLS and SECIO are currently preferred. If you'd like to test out the Noise transport, you can increase the priority of the noise transport: + +``` +ipfs config --json Swarm.Transports.Security.Noise 1 +``` + +Or even disable TLS and/or SECIO (not recommended for the moment): + +``` +ipfs config --json Swarm.Transports.Security.TLS false +ipfs config --json Swarm.Transports.Security.SECIO false +``` + +### Road to being a real feature + +- [ ] Needs real-world testing. +- [ ] Ideally a js-ipfs and a rust-ipfs release would include support for Noise. diff --git a/docs/file-transfer.md b/docs/file-transfer.md index 247993489ff..8f38ca76531 100644 --- a/docs/file-transfer.md +++ b/docs/file-transfer.md @@ -46,7 +46,9 @@ addresses (like the example below), then your nodes are online. "PublicKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDZb6znj3LQZKP1+X81exf+vbnqNCMtHjZ5RKTCm7Fytnfe+AI1fhs9YbZdkgFkM1HLxmIOLQj2bMXPIGxUM+EnewN8tWurx4B3+lR/LWNwNYcCFL+jF2ltc6SE6BC8kMLEZd4zidOLPZ8lIRpd0x3qmsjhGefuRwrKeKlR4tQ3C76ziOms47uLdiVVkl5LyJ5+mn4rXOjNKt/oy2O4m1St7X7/yNt8qQgYsPfe/hCOywxCEIHEkqmil+vn7bu4RpAtsUzCcBDoLUIWuU3i6qfytD05hP8Clo+at+l//ctjMxylf3IQ5qyP+yfvazk+WHcsB0tWueEmiU5P2nfUUIR3AgMBAAE=", "Addresses": [ "/ip4/127.0.0.1/tcp/4001/p2p/QmTNwsFkLAed15kQEC1ZJWPfoNbBQnMFojfJKQ9sZj1dk8", + "/ip4/127.0.0.1/udp/4001/quic/p2p/QmTNwsFkLAed15kQEC1ZJWPfoNbBQnMFojfJKQ9sZj1dk8", "/ip4/192.168.2.131/tcp/4001/p2p/QmTNwsFkLAed15kQEC1ZJWPfoNbBQnMFojfJKQ9sZj1dk8", + "/ip4/192.168.2.131/udp/4001/quic/p2p/QmTNwsFkLAed15kQEC1ZJWPfoNbBQnMFojfJKQ9sZj1dk8", ], "AgentVersion": "go-ipfs/0.4.11-dev/", "ProtocolVersion": "ipfs/0.1.0" @@ -90,8 +92,11 @@ Example output of addresses might look something like this: ``` /ip4/127.0.0.1/tcp/4001 +/ip4/127.0.0.1/udp/4001/quic /ip4/192.168.2.133/tcp/4001 +/ip4/192.168.2.133/udp/4001/quic /ip4/88.157.217.196/tcp/63674 +/ip4/88.157.217.196/udp/63674/quic ``` In this case, we can see a localhost (127.0.0.1) address, a LAN address (the diff --git a/fuse/ipns/ipns_unix.go b/fuse/ipns/ipns_unix.go index 64233a3be38..fa65c51c41d 100644 --- a/fuse/ipns/ipns_unix.go +++ b/fuse/ipns/ipns_unix.go @@ -188,7 +188,7 @@ func (s *Root) Lookup(ctx context.Context, name string) (fs.Node, error) { return nil, errors.New("invalid path from ipns record") } - return &Link{s.IpfsRoot + "/" + strings.TrimPrefix("/ipfs/", resolved.String())}, nil + return &Link{s.IpfsRoot + "/" + strings.TrimPrefix(resolved.String(), "/ipfs/")}, nil } func (r *Root) Close() error { diff --git a/go.mod b/go.mod index 3d0b512b934..0c1c393273f 100644 --- a/go.mod +++ b/go.mod @@ -10,14 +10,15 @@ require ( github.com/elgris/jsondiff v0.0.0-20160530203242-765b5c24c302 github.com/fatih/color v1.9.0 // indirect github.com/fsnotify/fsnotify v1.4.9 + github.com/gabriel-vasile/mimetype v1.1.0 github.com/go-bindata/go-bindata/v3 v3.1.3 github.com/gogo/protobuf v1.3.1 github.com/hashicorp/go-multierror v1.1.0 github.com/hashicorp/golang-lru v0.5.4 - github.com/ipfs/go-bitswap v0.2.13 + github.com/ipfs/go-bitswap v0.2.19 github.com/ipfs/go-block-format v0.0.2 github.com/ipfs/go-blockservice v0.1.3 - github.com/ipfs/go-cid v0.0.5 + github.com/ipfs/go-cid v0.0.6 github.com/ipfs/go-cidutil v0.0.2 github.com/ipfs/go-datastore v0.4.4 github.com/ipfs/go-detect-race v0.0.1 @@ -26,12 +27,12 @@ require ( github.com/ipfs/go-ds-leveldb v0.4.2 github.com/ipfs/go-ds-measure v0.1.0 github.com/ipfs/go-filestore v0.0.3 - github.com/ipfs/go-fs-lock v0.0.4 + github.com/ipfs/go-fs-lock v0.0.5 github.com/ipfs/go-graphsync v0.0.5 github.com/ipfs/go-ipfs-blockstore v0.1.4 github.com/ipfs/go-ipfs-chunker v0.0.5 - github.com/ipfs/go-ipfs-cmds v0.2.2 - github.com/ipfs/go-ipfs-config v0.5.3 + github.com/ipfs/go-ipfs-cmds v0.2.9 + github.com/ipfs/go-ipfs-config v0.8.0 github.com/ipfs/go-ipfs-ds-help v0.1.1 github.com/ipfs/go-ipfs-exchange-interface v0.0.1 github.com/ipfs/go-ipfs-exchange-offline v0.0.1 @@ -40,7 +41,7 @@ require ( github.com/ipfs/go-ipfs-posinfo v0.0.1 github.com/ipfs/go-ipfs-provider v0.4.3 github.com/ipfs/go-ipfs-routing v0.1.0 - github.com/ipfs/go-ipfs-util v0.0.1 + github.com/ipfs/go-ipfs-util v0.0.2 github.com/ipfs/go-ipld-cbor v0.0.4 github.com/ipfs/go-ipld-format v0.2.0 github.com/ipfs/go-ipld-git v0.0.3 @@ -49,61 +50,66 @@ require ( github.com/ipfs/go-merkledag v0.3.2 github.com/ipfs/go-metrics-interface v0.0.1 github.com/ipfs/go-metrics-prometheus v0.0.2 - github.com/ipfs/go-mfs v0.1.1 + github.com/ipfs/go-mfs v0.1.2 github.com/ipfs/go-path v0.0.7 github.com/ipfs/go-unixfs v0.2.4 github.com/ipfs/go-verifcid v0.0.1 - github.com/ipfs/interface-go-ipfs-core v0.2.7 + github.com/ipfs/interface-go-ipfs-core v0.3.0 github.com/ipld/go-car v0.1.0 - github.com/jbenet/go-is-domain v1.0.3 + github.com/jbenet/go-is-domain v1.0.5 github.com/jbenet/go-random v0.0.0-20190219211222-123a90aedc0c github.com/jbenet/go-temp-err-catcher v0.1.0 github.com/jbenet/goprocess v0.1.4 - github.com/libp2p/go-libp2p v0.8.3 - github.com/libp2p/go-libp2p-circuit v0.2.2 - github.com/libp2p/go-libp2p-connmgr v0.2.1 - github.com/libp2p/go-libp2p-core v0.5.3 + github.com/libp2p/go-libp2p v0.9.6 + github.com/libp2p/go-libp2p-circuit v0.2.3 + github.com/libp2p/go-libp2p-connmgr v0.2.4 + github.com/libp2p/go-libp2p-core v0.5.7 github.com/libp2p/go-libp2p-discovery v0.4.0 github.com/libp2p/go-libp2p-http v0.1.5 - github.com/libp2p/go-libp2p-kad-dht v0.7.11 - github.com/libp2p/go-libp2p-kbucket v0.4.1 + github.com/libp2p/go-libp2p-kad-dht v0.8.2 + github.com/libp2p/go-libp2p-kbucket v0.4.2 github.com/libp2p/go-libp2p-loggables v0.1.0 github.com/libp2p/go-libp2p-mplex v0.2.3 - github.com/libp2p/go-libp2p-peerstore v0.2.3 - github.com/libp2p/go-libp2p-pubsub v0.2.7 - github.com/libp2p/go-libp2p-pubsub-router v0.2.1 - github.com/libp2p/go-libp2p-quic-transport v0.3.7 - github.com/libp2p/go-libp2p-record v0.1.2 + github.com/libp2p/go-libp2p-noise v0.1.1 + github.com/libp2p/go-libp2p-peerstore v0.2.6 + github.com/libp2p/go-libp2p-pubsub v0.3.1 + github.com/libp2p/go-libp2p-pubsub-router v0.3.0 + github.com/libp2p/go-libp2p-quic-transport v0.6.0 + github.com/libp2p/go-libp2p-record v0.1.3 github.com/libp2p/go-libp2p-routing-helpers v0.2.3 github.com/libp2p/go-libp2p-secio v0.2.2 - github.com/libp2p/go-libp2p-swarm v0.2.3 + github.com/libp2p/go-libp2p-swarm v0.2.6 github.com/libp2p/go-libp2p-testing v0.1.1 github.com/libp2p/go-libp2p-tls v0.1.3 - github.com/libp2p/go-libp2p-yamux v0.2.7 - github.com/libp2p/go-maddr-filter v0.0.5 - github.com/libp2p/go-sockaddr v0.1.0 // indirect + github.com/libp2p/go-libp2p-yamux v0.2.8 github.com/libp2p/go-socket-activation v0.0.2 - github.com/mattn/go-runewidth v0.0.8 // indirect + github.com/libp2p/go-tcp-transport v0.2.0 + github.com/libp2p/go-ws-transport v0.3.1 + github.com/mattn/go-runewidth v0.0.9 // indirect + github.com/miekg/dns v1.1.29 // indirect github.com/mitchellh/go-homedir v1.1.0 github.com/mr-tron/base58 v1.1.3 - github.com/multiformats/go-multiaddr v0.2.1 + github.com/multiformats/go-multiaddr v0.2.2 github.com/multiformats/go-multiaddr-dns v0.2.0 github.com/multiformats/go-multiaddr-net v0.1.5 - github.com/multiformats/go-multibase v0.0.2 + github.com/multiformats/go-multibase v0.0.3 github.com/multiformats/go-multihash v0.0.13 github.com/opentracing/opentracing-go v1.1.0 github.com/pkg/errors v0.9.1 - github.com/prometheus/client_golang v1.5.1 + github.com/prometheus/client_golang v1.6.0 + github.com/stretchr/testify v1.6.1 github.com/syndtr/goleveldb v1.0.0 github.com/whyrusleeping/base32 v0.0.0-20170828182744-c30ac30633cc github.com/whyrusleeping/go-sysinfo v0.0.0-20190219211824-4a357d4b90b1 github.com/whyrusleeping/multiaddr-filter v0.0.0-20160516205228-e903e4adabd7 github.com/whyrusleeping/tar-utils v0.0.0-20180509141711-8c6c8ba81d5c go.uber.org/fx v1.12.0 - go.uber.org/zap v1.14.1 - golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5 - golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e // indirect - golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f + go.uber.org/zap v1.15.0 + golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37 + golang.org/x/lint v0.0.0-20200302205851-738671d3881b // indirect + golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2 // indirect + golang.org/x/sys v0.0.0-20200523222454-059865788121 + golang.org/x/tools v0.0.0-20200522201501-cb1345f3a375 // indirect gopkg.in/cheggaaa/pb.v1 v1.0.28 ) diff --git a/go.sum b/go.sum index 5d7c96789c3..6e1dbddf2ea 100644 --- a/go.sum +++ b/go.sum @@ -4,7 +4,22 @@ cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMT cloud.google.com/go v0.31.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= cloud.google.com/go v0.37.0/go.mod h1:TS1dMSSfndXH133OKGwekG838Om/cQT0BUHV3HcBgoo= +cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU= +cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU= +cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY= +cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= +cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= +cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= +cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= +cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= +cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= +cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= +cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= +cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= +cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw= +cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos= dmitri.shuralyov.com/app/changes v0.0.0-20180602232624-0a106ad413e3/go.mod h1:Yl+fi1br7+Rr3LqpNJf1/uxUdtRUV+Tnj0o93V2B9MU= +dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= dmitri.shuralyov.com/html/belt v0.0.0-20180602232347-f7d459c86be0/go.mod h1:JLBrvjyP0v+ecvNYvCpyZgu5/xkfAUhi6wJj28eUfSU= dmitri.shuralyov.com/service/change v0.0.0-20181023043359-a85b471d5412/go.mod h1:a1inKt/atXimZ4Mv927x+r7UpyzRUf4emIoiiSC2TN4= dmitri.shuralyov.com/state v0.0.0-20180228185332-28bcc343414c/go.mod h1:0PRwlb0D6DFvNNtx+9ybjezNCa8XF0xaYcETyp6rHWU= @@ -15,6 +30,7 @@ github.com/AndreasBriese/bbloom v0.0.0-20190825152654-46b345b51c96 h1:cTp8I5+VIo github.com/AndreasBriese/bbloom v0.0.0-20190825152654-46b345b51c96/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8= github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= github.com/Kubuxu/go-os-helper v0.0.1 h1:EJiD2VUQyh5A9hWJLmc6iWg6yIcJ7jpBcwC8GMGXfDk= github.com/Kubuxu/go-os-helper v0.0.1/go.mod h1:N8B+I7vPCT80IcP58r50u4+gEEcsZETFUpAzWW2ep1Y= github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= @@ -33,6 +49,10 @@ github.com/alexbrainman/goissue34681 v0.0.0-20191006012335-3fc7a47baff5 h1:iW0a5 github.com/alexbrainman/goissue34681 v0.0.0-20191006012335-3fc7a47baff5/go.mod h1:Y2QMoi1vgtOIfc+6DhrMOGkLoGzqSV2rKp4Sm+opsyA= github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c= github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= +github.com/benbjohnson/clock v1.0.1 h1:lVM1R/o5khtrr7t3qAr+sS6uagZOP+7iprc7gS3V9CE= +github.com/benbjohnson/clock v1.0.1/go.mod h1:bGMdMPoPVvcYyt1gHDf4J2KE153Yf9BuiUKYMaxlTDM= +github.com/benbjohnson/clock v1.0.2 h1:Z0CN0Yb4ig9sGPXkvAQcGJfnrrMQ5QYLCMPRi9iD7YE= +github.com/benbjohnson/clock v1.0.2/go.mod h1:bGMdMPoPVvcYyt1gHDf4J2KE153Yf9BuiUKYMaxlTDM= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= @@ -61,12 +81,16 @@ github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46f github.com/buger/jsonparser v0.0.0-20181115193947-bf1c66bbce23/go.mod h1:bbYlZJ7hK1yFx9hf58LP0zeX7UjIGs20ufpu3evjr+s= github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4= github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM= +github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko= github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY= github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/cheekybits/genny v1.0.0 h1:uGGa4nei+j20rOSeDeP5Of12XVm7TGUd4dJA9RDitfE= github.com/cheekybits/genny v1.0.0/go.mod h1:+tQajlRqAUrPI7DOSpB0XAqZYtQakVtB7wXkRAgjxjQ= +github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= +github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= +github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk= @@ -89,6 +113,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davidlazar/go-crypto v0.0.0-20170701192655-dcfb0a7ac018 h1:6xT9KW8zLC5IlbaIF5Q7JNieBoACT7iW0YTxQHR0in0= github.com/davidlazar/go-crypto v0.0.0-20170701192655-dcfb0a7ac018/go.mod h1:rQYf4tfk5sSwFsnDg3qYaBxSjsD9S8+59vW0dKUgme4= +github.com/davidlazar/go-crypto v0.0.0-20190912175916-7055855a373f h1:BOaYiTvg8p9vBUXpklC22XSK/mifLF7lG9jtmYYi3Tc= +github.com/davidlazar/go-crypto v0.0.0-20190912175916-7055855a373f/go.mod h1:rQYf4tfk5sSwFsnDg3qYaBxSjsD9S8+59vW0dKUgme4= github.com/dgraph-io/badger v1.5.5-0.20190226225317-8115aed38f8f/go.mod h1:VZxzAIRPHRVNRKRo6AXrX9BJegn6il06VMTZVJYCIjQ= github.com/dgraph-io/badger v1.6.0-rc1 h1:JphPpoBZJ3WHha133BGYlQqltSGIhV+VsEID0++nN9A= github.com/dgraph-io/badger v1.6.0-rc1/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4= @@ -105,18 +131,24 @@ github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/elgris/jsondiff v0.0.0-20160530203242-765b5c24c302 h1:QV0ZrfBLpFc2KDk+a4LJefDczXnonRwrYrQJY/9L4dA= github.com/elgris/jsondiff v0.0.0-20160530203242-765b5c24c302/go.mod h1:qBlWZqWeVx9BjvqBsnC/8RUlAYpIFmPvgROcw0n1scE= +github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4= +github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/facebookgo/atomicfile v0.0.0-20151019160806-2de1f203e7d5 h1:BBso6MBKW8ncyZLv37o+KNyy0HrrHgfnOaGQC2qvN+A= github.com/facebookgo/atomicfile v0.0.0-20151019160806-2de1f203e7d5/go.mod h1:JpoxHjuQauoxiFMl1ie8Xc/7TfLuMZ5eOCONd1sUBHg= github.com/fatih/color v1.9.0 h1:8xPHl4/q1VyqGIPif1F+1V3Y3lSmrq01EabUW3CoW5s= github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= github.com/fd/go-nat v1.0.0/go.mod h1:BTBu/CKvMmOMUPkKVef1pngt2WFH/lg7E6yQnulfp6E= github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc= +github.com/flynn/noise v0.0.0-20180327030543-2492fe189ae6 h1:u/UEqS66A5ckRmS4yNpjmVH56sVtS/RfclBAYocb4as= +github.com/flynn/noise v0.0.0-20180327030543-2492fe189ae6/go.mod h1:1i71OnUq3iUe1ma7Lr6yG6/rjvM3emb6yoL7xLFzcVQ= github.com/francoispqt/gojay v1.2.13 h1:d2m3sFjloqoIUQU3TsHBgj6qg/BVGlTBeHDUmyJnXKk= github.com/francoispqt/gojay v1.2.13/go.mod h1:ehT5mTG4ua4581f1++1WLG0vPdaA9HaiDsoyrBGkyDY= github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I= github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/gabriel-vasile/mimetype v1.1.0 h1:+ahX+MvQPFve4kO9Qjjxf3j49i0ACdV236kJlOCRAnU= +github.com/gabriel-vasile/mimetype v1.1.0/go.mod h1:6CDPel/o/3/s4+bp6kIbsWATq8pmgOisOPG40CJa6To= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0= github.com/go-bindata/go-bindata/v3 v3.1.3 h1:F0nVttLC3ws0ojc7p60veTurcOm//D4QBODNM7EGrCI= @@ -124,6 +156,8 @@ github.com/go-bindata/go-bindata/v3 v3.1.3/go.mod h1:1/zrpXsLD8YDIbhZRqXzm1Ghc7N github.com/go-check/check v0.0.0-20180628173108-788fd7840127 h1:0gkP6mzaMqkmpcJYCFOLkIBwI7xFExG03bbkOkCvUPI= github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98= github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q= +github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= +github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= @@ -139,10 +173,14 @@ github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXP github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6 h1:ZgQEtGgCBiWRM39fZuwSd1LwSqqSW0hOdXCYYDX0R3I= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e h1:1r7pUrabqp18hOBcwBwiTsbnFeTZHV9eER/QT5JVZxY= +github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.2.0 h1:28o5sBqPkBsMGnC6b4MvE2TzSr5/AT4c/1fLqVGIwlk= github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= github.com/golang/mock v1.4.0 h1:Rd1kQnQu0Hq3qvJppYSG0HtP+f5LPPUiDswTLiEegLg= github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= @@ -150,9 +188,17 @@ github.com/golang/protobuf v1.3.0/go.mod h1:Qd/q+1AKNOZr9uGQzbzCmRO6sUih6GTPZv6a github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw= +github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8= +github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA= +github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= +github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= +github.com/golang/protobuf v1.4.0 h1:oOuy+ugB+P/kBdUnG5QaMXSIyJ1q38wWSojYCb3z5VQ= +github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db h1:woRePGFeVFfLKN/pOkfl+p/TAqKOfFu+7KPlMVpok/w= github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY= github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= @@ -167,11 +213,15 @@ github.com/google/gopacket v1.1.17 h1:rMrlX2ZY2UbvT+sdz3+6J+pp2z+msCq9MxTU6ymxbB github.com/google/gopacket v1.1.17/go.mod h1:UdDNZ1OO62aGYVnPhxT1U6aI7ukYtA/kB8vaU0diBUM= github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= +github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY= github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY= github.com/googleapis/gax-go/v2 v2.0.3/go.mod h1:LLvjysVCY1JZeum8Z6l8qUty8fiNwE08qbEPm1M08qg= +github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= +github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/gopherjs/gopherjs v0.0.0-20190430165422-3e4dfb77656c h1:7lF+Vz0LqiRidnzC1Oq86fpX1q/iEv2KJdrCtttYjT4= github.com/gopherjs/gopherjs v0.0.0-20190430165422-3e4dfb77656c/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= @@ -191,8 +241,6 @@ github.com/hashicorp/go-multierror v1.1.0 h1:B9UzwGQJehnUY1yNrnwREHc3fGbC2xefo8g github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hashicorp/golang-lru v0.5.3 h1:YPkqC67at8FYaadspW/6uE0COsBxS2656RLEr8Bppgk= -github.com/hashicorp/golang-lru v0.5.3/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc= github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= @@ -202,6 +250,7 @@ github.com/huin/goupnp v0.0.0-20180415215157-1395d1447324/go.mod h1:MZ2ZmwcBpvOo github.com/huin/goupnp v1.0.0 h1:wg75sLpL6DZqwHQN6E1Cfk6mtfzS45z8OV+ic+DtHRo= github.com/huin/goupnp v1.0.0/go.mod h1:n9v9KO1tAxYH82qOn+UTIFQDmx5n1Zxd/ClZDMX7Bnc= github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o= +github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= github.com/ipfs/bbloom v0.0.1/go.mod h1:oqo8CVWsJFMOZqTglBG4wydCE4IQA/G2/SEofB0rjUI= github.com/ipfs/bbloom v0.0.4 h1:Gi+8EGJ2y5qiD5FbsbpX/TMNcJw8gSqr7eyjHa4Fhvs= @@ -212,8 +261,8 @@ github.com/ipfs/go-bitswap v0.1.0/go.mod h1:FFJEf18E9izuCqUtHxbWEvq+reg7o4CW5wSA github.com/ipfs/go-bitswap v0.1.2/go.mod h1:qxSWS4NXGs7jQ6zQvoPY3+NmOfHHG47mhkiLzBpJQIs= github.com/ipfs/go-bitswap v0.1.3/go.mod h1:YEQlFy0kkxops5Vy+OxWdRSEZIoS7I7KDIwoa5Chkps= github.com/ipfs/go-bitswap v0.1.8/go.mod h1:TOWoxllhccevbWFUR2N7B1MTSVVge1s6XSMiCSA4MzM= -github.com/ipfs/go-bitswap v0.2.13 h1:R8mUGpY0vwHljlnBeDE9PdR3DKKiPKevAMkq9qB8cyA= -github.com/ipfs/go-bitswap v0.2.13/go.mod h1:SDXpLeKZagyVVc8/z7sGtmM/lz8lyAmSzrUx3Ge3GXw= +github.com/ipfs/go-bitswap v0.2.19 h1:EhgRz8gqWQIBADY9gpqJOrfs5E1MtVfQFy1Vq8Z+Fq8= +github.com/ipfs/go-bitswap v0.2.19/go.mod h1:C7TwBgHnu89Q8sHsTJP7IhUqF9XYLe71P4tT5adgmYo= github.com/ipfs/go-block-format v0.0.1/go.mod h1:DK/YYcsSUIVAFNwo/KZCdIIbpN0ROH/baNLgayt4pFc= github.com/ipfs/go-block-format v0.0.2 h1:qPDvcP19izTjU8rgo6p7gTXZlkMkF5bz5G3fqIsSCPE= github.com/ipfs/go-block-format v0.0.2/go.mod h1:AWR46JfpcObNfg3ok2JHDUfdiHRgWhJgCQF+KIgOPJY= @@ -233,6 +282,8 @@ github.com/ipfs/go-cid v0.0.4 h1:UlfXKrZx1DjZoBhQHmNHLC1fK1dUJDN20Y28A7s+gJ8= github.com/ipfs/go-cid v0.0.4/go.mod h1:4LLaPOQwmk5z9LBgQnpkivrx8BJjUyGwTXCd5Xfj6+M= github.com/ipfs/go-cid v0.0.5 h1:o0Ix8e/ql7Zb5UVUJEUfjsWCIY8t48++9lR8qi6oiJU= github.com/ipfs/go-cid v0.0.5/go.mod h1:plgt+Y5MnOey4vO4UlUazGqdbEXuFYitED67FexhXog= +github.com/ipfs/go-cid v0.0.6 h1:go0y+GcDOGeJIV01FeBsta4FHngoA4Wz7KMeLkXAhMs= +github.com/ipfs/go-cid v0.0.6/go.mod h1:6Ux9z5e+HpkQdckYoX1PG/6xqKspzlEIR5SDmgqgC/I= github.com/ipfs/go-cidutil v0.0.2 h1:CNOboQf1t7Qp0nuNh8QMmhJs0+Q//bRL1axtCnIB1Yo= github.com/ipfs/go-cidutil v0.0.2/go.mod h1:ewllrvrxG6AMYStla3GD7Cqn+XYSLqjK0vc+086tB6s= github.com/ipfs/go-datastore v0.0.1/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE= @@ -274,8 +325,8 @@ github.com/ipfs/go-ds-measure v0.1.0 h1:vE4TyY4aeLeVgnnPBC5QzKIjKrqzha0NCujTfgvV github.com/ipfs/go-ds-measure v0.1.0/go.mod h1:1nDiFrhLlwArTME1Ees2XaBOl49OoCgd2A3f8EchMSY= github.com/ipfs/go-filestore v0.0.3 h1:MhZ1jT5K3NewZwim6rS/akcJLm1xM+r6nz6foeB9EwE= github.com/ipfs/go-filestore v0.0.3/go.mod h1:dvXRykFzyyXN2CdNlRGzDAkXMDPyI+D7JE066SiKLSE= -github.com/ipfs/go-fs-lock v0.0.4 h1:VhlO2E7awjMxkj6a4nCsrPScRFvEPZxhULtbYdJNZhQ= -github.com/ipfs/go-fs-lock v0.0.4/go.mod h1:SUaaFT1boYZewW+QBw5FZjcDbxkZIWgNdYb1ab93zaY= +github.com/ipfs/go-fs-lock v0.0.5 h1:nlKE27N7hlvsTXT3CSDkM6KRqgXpnaDjvyCHjAiZyK8= +github.com/ipfs/go-fs-lock v0.0.5/go.mod h1:fq8gXFwbi1on9KScveHuVJ2wjuqo5jaDgCtZdKLuCO8= github.com/ipfs/go-graphsync v0.0.5 h1:5U9iC58JgYfUSZI55oRXe22Cj6Ln0Xjd5VF4Eoo3foc= github.com/ipfs/go-graphsync v0.0.5/go.mod h1:SGKa4rVgCCz3KDNqe38wLEDYFa/PUF6w/ertGSQk33I= github.com/ipfs/go-ipfs-blockstore v0.0.1/go.mod h1:d3WClOmRQKFnJ0Jz/jj/zmksX0ma1gROTlovZKBmN08= @@ -289,10 +340,10 @@ github.com/ipfs/go-ipfs-chunker v0.0.1 h1:cHUUxKFQ99pozdahi+uSC/3Y6HeRpi9oTeUHbE github.com/ipfs/go-ipfs-chunker v0.0.1/go.mod h1:tWewYK0we3+rMbOh7pPFGDyypCtvGcBFymgY4rSDLAw= github.com/ipfs/go-ipfs-chunker v0.0.5 h1:ojCf7HV/m+uS2vhUGWcogIIxiO5ubl5O57Q7NapWLY8= github.com/ipfs/go-ipfs-chunker v0.0.5/go.mod h1:jhgdF8vxRHycr00k13FM8Y0E+6BoalYeobXmUyTreP8= -github.com/ipfs/go-ipfs-cmds v0.2.2 h1:F2pro/Q3ifRUsdxEKIS8cg8lO4R6WiwAyERiaG8I9no= -github.com/ipfs/go-ipfs-cmds v0.2.2/go.mod h1:kqlUrp6m2ceoaJe40cXpADCi5aS6NKRn0NIeuLp5CeM= -github.com/ipfs/go-ipfs-config v0.5.3 h1:3GpI/xR9FoJNTjU6YvCMRbYyEi0dBVY5UtlUTcNRlSA= -github.com/ipfs/go-ipfs-config v0.5.3/go.mod h1:nSLCFtlaL+2rbl3F+9D4gQZQbT1LjRKx7TJg/IHz6oM= +github.com/ipfs/go-ipfs-cmds v0.2.9 h1:zQTENe9UJrtCb2bOtRoDGjtuo3rQjmuPdPnVlqoBV/M= +github.com/ipfs/go-ipfs-cmds v0.2.9/go.mod h1:ZgYiWVnCk43ChwoH8hAmI1IRbuVtq3GSTHwtRB/Kqhk= +github.com/ipfs/go-ipfs-config v0.8.0 h1:4Tc7DC3dz4e7VadOjxXxFQGTQ1g7EYZClJ/ih8qOrxE= +github.com/ipfs/go-ipfs-config v0.8.0/go.mod h1:GQUxqb0NfkZmEU92PxqqqLVVFTLpoGGUlBaTyDaAqrE= github.com/ipfs/go-ipfs-delay v0.0.0-20181109222059-70721b86a9a8/go.mod h1:8SP1YXK1M1kXuc4KJZINY3TQQ03J2rwBG9QfXmbRPrw= github.com/ipfs/go-ipfs-delay v0.0.1 h1:r/UXYyRcddO6thwOnhiznIAiSvxMECGgtv35Xs1IeRQ= github.com/ipfs/go-ipfs-delay v0.0.1/go.mod h1:8SP1YXK1M1kXuc4KJZINY3TQQ03J2rwBG9QfXmbRPrw= @@ -324,6 +375,8 @@ github.com/ipfs/go-ipfs-routing v0.1.0 h1:gAJTT1cEeeLj6/DlLX6t+NxD9fQe2ymTO6qWRD github.com/ipfs/go-ipfs-routing v0.1.0/go.mod h1:hYoUkJLyAUKhF58tysKpids8RNDPO42BVMgK5dNsoqY= github.com/ipfs/go-ipfs-util v0.0.1 h1:Wz9bL2wB2YBJqggkA4dD7oSmqB4cAnpNbGrlHJulv50= github.com/ipfs/go-ipfs-util v0.0.1/go.mod h1:spsl5z8KUnrve+73pOhSVZND1SIxPW5RyBCNzQxlJBc= +github.com/ipfs/go-ipfs-util v0.0.2 h1:59Sswnk1MFaiq+VcaknX7aYEyGyGDAA73ilhEK2POp8= +github.com/ipfs/go-ipfs-util v0.0.2/go.mod h1:CbPtkWJzjLdEcezDns2XYaehFVNXG9zrdrtMecczcsQ= github.com/ipfs/go-ipld-cbor v0.0.1/go.mod h1:RXHr8s4k0NE0TKhnrxqZC9M888QfsBN9rhS5NjfKzY8= github.com/ipfs/go-ipld-cbor v0.0.2/go.mod h1:wTBtrQZA3SoFKMVkp6cn6HMRteIB1VsmHA0AQFOn7Nc= github.com/ipfs/go-ipld-cbor v0.0.3 h1:ENsxvybwkmke7Z/QJOmeJfoguj6GH3Y0YOaGrfy9Q0I= @@ -357,6 +410,8 @@ github.com/ipfs/go-log/v2 v2.0.3 h1:Q2gXcBoCALyLN/pUQlz1qgu0x3uFV6FzP9oXhpfyJpc= github.com/ipfs/go-log/v2 v2.0.3/go.mod h1:O7P1lJt27vWHhOwQmcFEvlmo49ry2VY2+JfBWFaa9+0= github.com/ipfs/go-log/v2 v2.0.5 h1:fL4YI+1g5V/b1Yxr1qAiXTMg1H8z9vx/VmJxBuQMHvU= github.com/ipfs/go-log/v2 v2.0.5/go.mod h1:eZs4Xt4ZUJQFM3DlanGhy7TkwwawCZcSByscwkWG+dw= +github.com/ipfs/go-log/v2 v2.0.8 h1:3b3YNopMHlj4AvyhWAx0pDxqSQWYi4/WuWO7yRV6/Qg= +github.com/ipfs/go-log/v2 v2.0.8/go.mod h1:eZs4Xt4ZUJQFM3DlanGhy7TkwwawCZcSByscwkWG+dw= github.com/ipfs/go-merkledag v0.0.3/go.mod h1:Oc5kIXLHokkE1hWGMBHw+oxehkAaTOqtEb7Zbh6BhLA= github.com/ipfs/go-merkledag v0.0.6/go.mod h1:QYPdnlvkOg7GnQRofu9XZimC5ZW5Wi3bKys/4GQQfto= github.com/ipfs/go-merkledag v0.1.0/go.mod h1:SQiXrtSts3KGNmgOzMICy5c0POOpUNQLvB3ClKnBAlk= @@ -373,8 +428,8 @@ github.com/ipfs/go-metrics-interface v0.0.1 h1:j+cpbjYvu4R8zbleSs36gvB7jR+wsL2fG github.com/ipfs/go-metrics-interface v0.0.1/go.mod h1:6s6euYU4zowdslK0GKHmqaIZ3j/b/tL7HTWtJ4VPgWY= github.com/ipfs/go-metrics-prometheus v0.0.2 h1:9i2iljLg12S78OhC6UAiXi176xvQGiZaGVF1CUVdE+s= github.com/ipfs/go-metrics-prometheus v0.0.2/go.mod h1:ELLU99AQQNi+zX6GCGm2lAgnzdSH3u5UVlCdqSXnEks= -github.com/ipfs/go-mfs v0.1.1 h1:tjYEWFIl0W6vRFuM/EnySHaaYzPmDcQWwTjtYWMGQ1A= -github.com/ipfs/go-mfs v0.1.1/go.mod h1:nk17h6kCOrfaNqXvx2VJ3SqkJ0VYUzJFAsc+BA0sqaw= +github.com/ipfs/go-mfs v0.1.2 h1:DlelNSmH+yz/Riy0RjPKlooPg0KML4lXGdLw7uZkfAg= +github.com/ipfs/go-mfs v0.1.2/go.mod h1:T1QBiZPEpkPLzDqEJLNnbK55BVKVlNi2a+gVm4diFo0= github.com/ipfs/go-path v0.0.3/go.mod h1:zIRQUez3LuQIU25zFjC2hpBTHimWx7VK5bjZgRLbbdo= github.com/ipfs/go-path v0.0.7 h1:H06hKMquQ0aYtHiHryOMLpQC1qC3QwXwkahcEVD51Ho= github.com/ipfs/go-path v0.0.7/go.mod h1:6KTKmeRnBXgqrTvzFrPV3CamxcgvXX/4z79tfAd2Sno= @@ -390,8 +445,8 @@ github.com/ipfs/go-unixfs v0.2.4 h1:6NwppOXefWIyysZ4LR/qUBPvXd5//8J3jiMdvpbw6Lo= github.com/ipfs/go-unixfs v0.2.4/go.mod h1:SUdisfUjNoSDzzhGVxvCL9QO/nKdwXdr+gbMUdqcbYw= github.com/ipfs/go-verifcid v0.0.1 h1:m2HI7zIuR5TFyQ1b79Da5N9dnnCP1vcu2QqawmWlK2E= github.com/ipfs/go-verifcid v0.0.1/go.mod h1:5Hrva5KBeIog4A+UpqlaIU+DEstipcJYQQZc0g37pY0= -github.com/ipfs/interface-go-ipfs-core v0.2.7 h1:HCwVmU9Tmba6jdMGxMcPsfwKUBY4y+6bLHp8T+t9hTU= -github.com/ipfs/interface-go-ipfs-core v0.2.7/go.mod h1:Tihp8zxGpUeE3Tokr94L6zWZZdkRQvG5TL6i9MuNE+s= +github.com/ipfs/interface-go-ipfs-core v0.3.0 h1:oZdLLfh256gPGcYPURjivj/lv296GIcr8mUqZUnXOEI= +github.com/ipfs/interface-go-ipfs-core v0.3.0/go.mod h1:Tihp8zxGpUeE3Tokr94L6zWZZdkRQvG5TL6i9MuNE+s= github.com/ipld/go-car v0.1.0 h1:AaIEA5ITRnFA68uMyuIPYGM2XXllxsu8sNjFJP797us= github.com/ipld/go-car v0.1.0/go.mod h1:RCWzaUh2i4mOEkB3W45Vc+9jnS/M6Qay5ooytiBHl3g= github.com/ipld/go-ipld-prime v0.0.2-0.20191108012745-28a82f04c785 h1:fASnkvtR+SmB2y453RxmDD3Uvd4LonVUgFGk9JoDaZs= @@ -408,8 +463,8 @@ github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+ github.com/jbenet/go-cienv v0.0.0-20150120210510-1bb1476777ec/go.mod h1:rGaEvXB4uRSZMmzKNLoXvTu1sfx+1kv/DojUlPrSZGs= github.com/jbenet/go-cienv v0.1.0 h1:Vc/s0QbQtoxX8MwwSLWWh+xNNZvM3Lw7NsTcHrvvhMc= github.com/jbenet/go-cienv v0.1.0/go.mod h1:TqNnHUmJgXau0nCzC7kXWeotg3J9W34CUv5Djy1+FlA= -github.com/jbenet/go-is-domain v1.0.3 h1:FuRBJ0h79p00eseyaLckJT5KnE8RyqI+HLopvNSyNE0= -github.com/jbenet/go-is-domain v1.0.3/go.mod h1:xbRLRb0S7FgzDBTJlguhDVwLYM/5yNtvktxj2Ttfy7Q= +github.com/jbenet/go-is-domain v1.0.5 h1:r92uiHbMEJo9Fkey5pMBtZAzjPQWic0ieo7Jw1jEuQQ= +github.com/jbenet/go-is-domain v1.0.5/go.mod h1:xbRLRb0S7FgzDBTJlguhDVwLYM/5yNtvktxj2Ttfy7Q= github.com/jbenet/go-random v0.0.0-20190219211222-123a90aedc0c h1:uUx61FiAa1GI6ZmVd2wf2vULeQZIKG66eybjNXKYCz4= github.com/jbenet/go-random v0.0.0-20190219211222-123a90aedc0c/go.mod h1:sdx1xVM9UuLw1tXnhJWN3piypTUO3vCIHYmG15KE/dU= github.com/jbenet/go-temp-err-catcher v0.0.0-20150120210811-aac704a3f4f2 h1:vhC1OXXiT9R2pczegwz6moDvuRpggaroAXhPIseh57A= @@ -428,6 +483,7 @@ github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlT github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= +github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo= github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= @@ -454,6 +510,8 @@ github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/libp2p/go-addr-util v0.0.1 h1:TpTQm9cXVRVSKsYbgQ7GKc3KbbHVTnbostgGaDEP+88= github.com/libp2p/go-addr-util v0.0.1/go.mod h1:4ac6O7n9rIAKB1dnd+s8IbbMXkt+oBpzX4/+RACcnlQ= +github.com/libp2p/go-addr-util v0.0.2 h1:7cWK5cdA5x72jX0g8iLrQWm5TRJZ6CzGdPEhWj7plWU= +github.com/libp2p/go-addr-util v0.0.2/go.mod h1:Ecd6Fb3yIuLzq4bD7VcywcVSBtefcAwnUISBM3WG15E= github.com/libp2p/go-buffer-pool v0.0.1/go.mod h1:xtyIz9PMobb13WaxR6Zo1Pd1zXJKYg0a8KiIvDp3TzQ= github.com/libp2p/go-buffer-pool v0.0.2 h1:QNK2iAFa8gjAe1SPz6mHSMuCcjs+X1wlHzeOSqcmlfs= github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoRZd1Vi32+RXyFM= @@ -468,6 +526,8 @@ github.com/libp2p/go-eventbus v0.0.2/go.mod h1:Hr/yGlwxA/stuLnpMiu82lpNKpvRy3EaJ github.com/libp2p/go-eventbus v0.0.3/go.mod h1:Hr/yGlwxA/stuLnpMiu82lpNKpvRy3EaJxPu40XYOwk= github.com/libp2p/go-eventbus v0.1.0 h1:mlawomSAjjkk97QnYiEmHsLu7E136+2oCWSHRUvMfzQ= github.com/libp2p/go-eventbus v0.1.0/go.mod h1:vROgu5cs5T7cv7POWlWxBaVLxfSegC5UGQf8A2eEmx4= +github.com/libp2p/go-eventbus v0.2.1 h1:VanAdErQnpTioN2TowqNcOijf6YwhuODe4pPKSDpxGc= +github.com/libp2p/go-eventbus v0.2.1/go.mod h1:jc2S4SoEVPP48H9Wpzm5aiGwUCBMfGhVhhBjyhhCJs8= github.com/libp2p/go-flow-metrics v0.0.1 h1:0gxuFd2GuK7IIP5pKljLwps6TvcuYgvG7Atqi3INF5s= github.com/libp2p/go-flow-metrics v0.0.1/go.mod h1:Iv1GH0sG8DtYN3SVJ2eG221wMiNpZxBdp967ls1g+k8= github.com/libp2p/go-flow-metrics v0.0.2 h1:U5TvqfoyR6GVRM+bC15Ux1ltar1kbj6Zw6xOVR02CZs= @@ -487,10 +547,13 @@ github.com/libp2p/go-libp2p v0.7.0 h1:qWmciout2lJclKfRlxqdepsQB7JihcbRhgcRcssP4r github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xSU1ivxn0k= github.com/libp2p/go-libp2p v0.7.4 h1:xVj1oSlN0C+FlxqiLuHC8WruMvq24xxfeVxmNhTG0r0= 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.8.2 h1:gVuk8nZGjnRagJ/mLpBCSJw7bW1yWJrq3EwOk/AC6FM= github.com/libp2p/go-libp2p v0.8.2/go.mod h1:NQDA/F/qArMHGe0J7sDScaKjW8Jh4y/ozQqBbYJ+BnA= github.com/libp2p/go-libp2p v0.8.3 h1:IFWeNzxkBaNO1N8stN9ayFGdC6RmVuSsKd5bou7qpK0= github.com/libp2p/go-libp2p v0.8.3/go.mod h1:EsH1A+8yoWK+L4iKcbPYu6MPluZ+CHWI9El8cTaefiM= +github.com/libp2p/go-libp2p v0.9.6 h1:sDiuVhuLpWQOjSFmxOJEXVM9RHKIUTKgi8ArSS9nBtE= +github.com/libp2p/go-libp2p v0.9.6/go.mod h1:EA24aHpFs3BscMWvO286AiaKs3a7efQdLo+tbZ2tUSk= github.com/libp2p/go-libp2p-autonat v0.0.2/go.mod h1:fs71q5Xk+pdnKU014o2iq1RhMs9/PMaG5zXRFNnIIT4= github.com/libp2p/go-libp2p-autonat v0.0.6/go.mod h1:uZneLdOkZHro35xIhpbtTzLlgYturpu4J5+0cZK3MqE= github.com/libp2p/go-libp2p-autonat v0.1.0 h1:aCWAu43Ri4nU0ZPO7NyLzUvvfqd0nE3dX0R/ZGYVgOU= @@ -503,11 +566,15 @@ github.com/libp2p/go-libp2p-autonat v0.2.1 h1:T0CRQhrvTBKfBSYw6Xo2K3ixtNpAnRCrax github.com/libp2p/go-libp2p-autonat v0.2.1/go.mod h1:MWtAhV5Ko1l6QBsHQNSuM6b1sRkXrpk0/LqCr+vCVxI= github.com/libp2p/go-libp2p-autonat v0.2.2 h1:4dlgcEEugTFWSvdG2UIFxhnOMpX76QaZSRAtXmYB8n4= github.com/libp2p/go-libp2p-autonat v0.2.2/go.mod h1:HsM62HkqZmHR2k1xgX34WuWDzk/nBwNHoeyyT4IWV6A= +github.com/libp2p/go-libp2p-autonat v0.2.3 h1:w46bKK3KTOUWDe5mDYMRjJu1uryqBp8HCNDp/TWMqKw= +github.com/libp2p/go-libp2p-autonat v0.2.3/go.mod h1:2U6bNWCNsAG9LEbwccBDQbjzQ8Krdjge1jLTE9rdoMM= github.com/libp2p/go-libp2p-blankhost v0.0.1/go.mod h1:Ibpbw/7cPPYwFb7PACIWdvxxv0t0XCCI10t7czjAjTc= github.com/libp2p/go-libp2p-blankhost v0.1.1/go.mod h1:pf2fvdLJPsC1FsVrNP3DUUvMzUts2dsLLBEpo1vW1ro= github.com/libp2p/go-libp2p-blankhost v0.1.3/go.mod h1:KML1//wiKR8vuuJO0y3LUd1uLv+tlkGTAr3jC0S5cLg= github.com/libp2p/go-libp2p-blankhost v0.1.4 h1:I96SWjR4rK9irDHcHq3XHN6hawCRTPUADzkJacgZLvk= github.com/libp2p/go-libp2p-blankhost v0.1.4/go.mod h1:oJF0saYsAXQCSfDq254GMNmLNz6ZTHTOvtF4ZydUvwU= +github.com/libp2p/go-libp2p-blankhost v0.1.6 h1:CkPp1/zaCrCnBo0AdsQA0O1VkUYoUOtyHOnoa8gKIcE= +github.com/libp2p/go-libp2p-blankhost v0.1.6/go.mod h1:jONCAJqEP+Z8T6EQviGL4JsQcLx1LgTGtVqFNY8EMfQ= github.com/libp2p/go-libp2p-circuit v0.0.1/go.mod h1:Dqm0s/BiV63j8EEAs8hr1H5HudqvCAeXxDyic59lCwE= github.com/libp2p/go-libp2p-circuit v0.0.9/go.mod h1:uU+IBvEQzCu953/ps7bYzC/D/R0Ho2A9LfKVVCatlqU= github.com/libp2p/go-libp2p-circuit v0.1.0/go.mod h1:Ahq4cY3V9VJcHcn1SBXjr78AbFkZeIRmfunbA7pmFh8= @@ -517,8 +584,12 @@ github.com/libp2p/go-libp2p-circuit v0.2.1 h1:BDiBcQxX/ZJJ/yDl3sqZt1bjj4PkZCEi7I github.com/libp2p/go-libp2p-circuit v0.2.1/go.mod h1:BXPwYDN5A8z4OEY9sOfr2DUQMLQvKt/6oku45YUmjIo= github.com/libp2p/go-libp2p-circuit v0.2.2 h1:87RLabJ9lrhoiSDDZyCJ80ZlI5TLJMwfyoGAaWXzWqA= github.com/libp2p/go-libp2p-circuit v0.2.2/go.mod h1:nkG3iE01tR3FoQ2nMm06IUrCpCyJp1Eo4A1xYdpjfs4= -github.com/libp2p/go-libp2p-connmgr v0.2.1 h1:1ed0HFhCb39sIMK7QYgRBW0vibBBqFQMs4xt9a9AalY= -github.com/libp2p/go-libp2p-connmgr v0.2.1/go.mod h1:JReKEFcgzSHKT9lL3rhYcUtXBs9uMIiMKJGM1tl3xJE= +github.com/libp2p/go-libp2p-circuit v0.2.3 h1:3Uw1fPHWrp1tgIhBz0vSOxRUmnKL8L/NGUyEd5WfSGM= +github.com/libp2p/go-libp2p-circuit v0.2.3/go.mod h1:nkG3iE01tR3FoQ2nMm06IUrCpCyJp1Eo4A1xYdpjfs4= +github.com/libp2p/go-libp2p-connmgr v0.2.3 h1:v7skKI9n+0obPpzMIO6aIlOSdQOmhxTf40cbpzqaGMQ= +github.com/libp2p/go-libp2p-connmgr v0.2.3/go.mod h1:Gqjg29zI8CwXX21zRxy6gOg8VYu3zVerJRt2KyktzH4= +github.com/libp2p/go-libp2p-connmgr v0.2.4 h1:TMS0vc0TCBomtQJyWr7fYxcVYYhx+q/2gF++G5Jkl/w= +github.com/libp2p/go-libp2p-connmgr v0.2.4/go.mod h1:YV0b/RIm8NGPnnNWM7hG9Q38OeQiQfKhHCCs1++ufn0= github.com/libp2p/go-libp2p-core v0.0.1/go.mod h1:g/VxnTZ/1ygHxH3dKok7Vno1VfpvGcGip57wjTU4fco= github.com/libp2p/go-libp2p-core v0.0.2/go.mod h1:9dAcntw/n46XycV4RnlBq3BpgrmyUi9LuoTNdPrbUco= github.com/libp2p/go-libp2p-core v0.0.3/go.mod h1:j+YQMNz9WNSkNezXOsahp9kwZBKBvxLpKD316QWSJXE= @@ -544,6 +615,12 @@ github.com/libp2p/go-libp2p-core v0.5.2 h1:hevsCcdLiazurKBoeNn64aPYTVOPdY4phaEGe github.com/libp2p/go-libp2p-core v0.5.2/go.mod h1:uN7L2D4EvPCvzSH5SrhR72UWbnSGpt5/a35Sm4upn4Y= github.com/libp2p/go-libp2p-core v0.5.3 h1:b9W3w7AZR2n/YJhG8d0qPFGhGhCWKIvPuJgp4hhc4MM= github.com/libp2p/go-libp2p-core v0.5.3/go.mod h1:uN7L2D4EvPCvzSH5SrhR72UWbnSGpt5/a35Sm4upn4Y= +github.com/libp2p/go-libp2p-core v0.5.4/go.mod h1:uN7L2D4EvPCvzSH5SrhR72UWbnSGpt5/a35Sm4upn4Y= +github.com/libp2p/go-libp2p-core v0.5.5/go.mod h1:vj3awlOr9+GMZJFH9s4mpt9RHHgGqeHCopzbYKZdRjM= +github.com/libp2p/go-libp2p-core v0.5.6 h1:IxFH4PmtLlLdPf4fF/i129SnK/C+/v8WEX644MxhC48= +github.com/libp2p/go-libp2p-core v0.5.6/go.mod h1:txwbVEhHEXikXn9gfC7/UDDw7rkxuX0bJvM49Ykaswo= +github.com/libp2p/go-libp2p-core v0.5.7 h1:QK3xRwFxqd0Xd9bSZL+8yZ8ncZZbl6Zngd/+Y+A6sgQ= +github.com/libp2p/go-libp2p-core v0.5.7/go.mod h1:txwbVEhHEXikXn9gfC7/UDDw7rkxuX0bJvM49Ykaswo= github.com/libp2p/go-libp2p-crypto v0.0.1/go.mod h1:yJkNyDmO341d5wwXxDUGO0LykUVT72ImHNUqh5D/dBE= github.com/libp2p/go-libp2p-crypto v0.0.2/go.mod h1:eETI5OUfBnvARGOHrJz2eWNyTUxEGZnBxMcbUjfIj4I= github.com/libp2p/go-libp2p-crypto v0.1.0 h1:k9MFy+o2zGDNGsaoZl0MA3iZ75qXxr9OOoAZF+sD5OQ= @@ -568,10 +645,10 @@ github.com/libp2p/go-libp2p-interface-connmgr v0.0.1/go.mod h1:GarlRLH0LdeWcLnYM github.com/libp2p/go-libp2p-interface-connmgr v0.0.4/go.mod h1:GarlRLH0LdeWcLnYM/SaBykKFl9U5JFnbBGruAk/D5k= github.com/libp2p/go-libp2p-interface-connmgr v0.0.5/go.mod h1:GarlRLH0LdeWcLnYM/SaBykKFl9U5JFnbBGruAk/D5k= github.com/libp2p/go-libp2p-interface-pnet v0.0.1/go.mod h1:el9jHpQAXK5dnTpKA4yfCNBZXvrzdOU75zz+C6ryp3k= -github.com/libp2p/go-libp2p-kad-dht v0.7.11 h1:MP0DEuxO/Blg1AklIVV1P4R5xtYX+ZyXBCtEN7f60yQ= -github.com/libp2p/go-libp2p-kad-dht v0.7.11/go.mod h1:1ht6+bG3Or+fNNERWPYmLacs6TN0CxBkFB5IKIWWwOI= -github.com/libp2p/go-libp2p-kbucket v0.4.1 h1:6FyzbQuGLPzbMv3HiD232zqscIz5iB8ppJwb380+OGI= -github.com/libp2p/go-libp2p-kbucket v0.4.1/go.mod h1:7sCeZx2GkNK1S6lQnGUW5JYZCFPnXzAZCCBBS70lytY= +github.com/libp2p/go-libp2p-kad-dht v0.8.2 h1:s7y38B+hdj1AkNR3PCTpvNqBsZHxOf7hoUy7+fNlSZQ= +github.com/libp2p/go-libp2p-kad-dht v0.8.2/go.mod h1:u3rbYbp3CSraAHD5s81CJ3hHozKTud/UOXfAgh93Gek= +github.com/libp2p/go-libp2p-kbucket v0.4.2 h1:wg+VPpCtY61bCasGRexCuXOmEmdKjN+k1w+JtTwu9gA= +github.com/libp2p/go-libp2p-kbucket v0.4.2/go.mod h1:7sCeZx2GkNK1S6lQnGUW5JYZCFPnXzAZCCBBS70lytY= github.com/libp2p/go-libp2p-loggables v0.0.1/go.mod h1:lDipDlBNYbpyqyPX/KcoO+eq0sJYEVR2JgOexcivchg= github.com/libp2p/go-libp2p-loggables v0.1.0 h1:h3w8QFfCt2UJl/0/NW4K829HX/0S4KD31PQ7m8UXXO8= github.com/libp2p/go-libp2p-loggables v0.1.0/go.mod h1:EyumB2Y6PrYjr55Q3/tiJ/o3xoDasoRYM7nOzEpoa90= @@ -596,6 +673,8 @@ github.com/libp2p/go-libp2p-net v0.0.2/go.mod h1:Yt3zgmlsHOgUWSXmt5V/Jpz9upuJBE8 github.com/libp2p/go-libp2p-netutil v0.0.1/go.mod h1:GdusFvujWZI9Vt0X5BKqwWWmZFxecf9Gt03cKxm2f/Q= github.com/libp2p/go-libp2p-netutil v0.1.0 h1:zscYDNVEcGxyUpMd0JReUZTrpMfia8PmLKcKF72EAMQ= github.com/libp2p/go-libp2p-netutil v0.1.0/go.mod h1:3Qv/aDqtMLTUyQeundkKsA+YCThNdbQD54k3TqjpbFU= +github.com/libp2p/go-libp2p-noise v0.1.1 h1:vqYQWvnIcHpIoWJKC7Al4D6Hgj0H012TuXRhPwSMGpQ= +github.com/libp2p/go-libp2p-noise v0.1.1/go.mod h1:QDFLdKX7nluB7DEnlVPbz7xlLHdwHFA9HiohJRr3vwM= github.com/libp2p/go-libp2p-peer v0.0.1/go.mod h1:nXQvOBbwVqoP+T5Y5nCjeH4sP9IX/J0AMzcDUVruVoo= github.com/libp2p/go-libp2p-peer v0.1.1/go.mod h1:jkF12jGB4Gk/IOo+yomm+7oLWxF278F7UnrYUQ1Q8es= github.com/libp2p/go-libp2p-peer v0.2.0 h1:EQ8kMjaCUwt/Y5uLgjT8iY2qg0mGUT0N1zUjer50DsY= @@ -616,22 +695,29 @@ github.com/libp2p/go-libp2p-peerstore v0.2.2 h1:iqc/m03jHn5doXN3+kS6JKvqQRHEltiX github.com/libp2p/go-libp2p-peerstore v0.2.2/go.mod h1:NQxhNjWxf1d4w6PihR8btWIRjwRLBr4TYKfNgrUkOPA= github.com/libp2p/go-libp2p-peerstore v0.2.3 h1:MofRq2l3c15vQpEygTetV+zRRrncz+ktiXW7H2EKoEQ= github.com/libp2p/go-libp2p-peerstore v0.2.3/go.mod h1:K8ljLdFn590GMttg/luh4caB/3g0vKuY01psze0upRw= +github.com/libp2p/go-libp2p-peerstore v0.2.4 h1:jU9S4jYN30kdzTpDAR7SlHUD+meDUjTODh4waLWF1ws= +github.com/libp2p/go-libp2p-peerstore v0.2.4/go.mod h1:ss/TWTgHZTMpsU/oKVVPQCGuDHItOpf2W8RxAi50P2s= +github.com/libp2p/go-libp2p-peerstore v0.2.6 h1:2ACefBX23iMdJU9Ke+dcXt3w86MIryes9v7In4+Qq3U= +github.com/libp2p/go-libp2p-peerstore v0.2.6/go.mod h1:ss/TWTgHZTMpsU/oKVVPQCGuDHItOpf2W8RxAi50P2s= github.com/libp2p/go-libp2p-pnet v0.2.0 h1:J6htxttBipJujEjz1y0a5+eYoiPcFHhSYHH6na5f0/k= github.com/libp2p/go-libp2p-pnet v0.2.0/go.mod h1:Qqvq6JH/oMZGwqs3N1Fqhv8NVhrdYcO0BW4wssv21LA= github.com/libp2p/go-libp2p-protocol v0.0.1/go.mod h1:Af9n4PiruirSDjHycM1QuiMi/1VZNHYcK8cLgFJLZ4s= github.com/libp2p/go-libp2p-protocol v0.1.0/go.mod h1:KQPHpAabB57XQxGrXCNvbL6UEXfQqUgC/1adR2Xtflk= -github.com/libp2p/go-libp2p-pubsub v0.2.5 h1:tPKbkjAUI0xLGN3KKTKKy9TQEviVfrP++zJgH5Muke4= -github.com/libp2p/go-libp2p-pubsub v0.2.5/go.mod h1:9Q2RRq8ofXkoewORcyVlgUFDKLKw7BuYSlJVWRcVk3Y= -github.com/libp2p/go-libp2p-pubsub v0.2.7 h1:PBuK5+NfWsoaoEaAUZ7YQPETQh8UqBi8CbMJ1CZ5sNI= -github.com/libp2p/go-libp2p-pubsub v0.2.7/go.mod h1:R4R0kH/6p2vu8O9xsue0HNSjEuXMEPBgg4h3nVDI15o= -github.com/libp2p/go-libp2p-pubsub-router v0.2.1 h1:F5JYaHQuuMKVbSgLsH2POQwT1rloWpc7fUCOq6PBjyE= -github.com/libp2p/go-libp2p-pubsub-router v0.2.1/go.mod h1:cl46APmxgKgzgpCGFb8Ns7++cqnJ29CxESXCQATp55k= -github.com/libp2p/go-libp2p-quic-transport v0.3.7 h1:F9hxonkJvMipNim8swrvRk2uL9s8pqzHz0M6eMf8L58= +github.com/libp2p/go-libp2p-pubsub v0.3.0 h1:K5FSYyfcSrJWrGExgdbogCLMqwC3pQaXEVt2CaUy1SA= +github.com/libp2p/go-libp2p-pubsub v0.3.0/go.mod h1:TxPOBuo1FPdsTjFnv+FGZbNbWYsp74Culx+4ViQpato= +github.com/libp2p/go-libp2p-pubsub v0.3.1 h1:7Hyv2d8BK/x1HGRJTZ8X++VQEP+WqDTSwpUSZGTVLYA= +github.com/libp2p/go-libp2p-pubsub v0.3.1/go.mod h1:TxPOBuo1FPdsTjFnv+FGZbNbWYsp74Culx+4ViQpato= +github.com/libp2p/go-libp2p-pubsub-router v0.3.0 h1:ghpHApTMXN+aZ+InYvpJa/ckBW4orypzNI0aWQDth3s= +github.com/libp2p/go-libp2p-pubsub-router v0.3.0/go.mod h1:6kZb1gGV1yGzXTfyNsi4p+hyt1JnA1OMGHeExTOJR3A= github.com/libp2p/go-libp2p-quic-transport v0.3.7/go.mod h1:Kr4aDtnfHHNeENn5J+sZIVc+t8HpQn9W6BOxhVGHbgI= +github.com/libp2p/go-libp2p-quic-transport v0.6.0 h1:d5bcq7y+t6IiumD9Ib0S4oHgWu66rRjQ1Y8ligii6G8= +github.com/libp2p/go-libp2p-quic-transport v0.6.0/go.mod h1:HR435saAZhTrFabI+adf3tVBY7ZJg5rKNoJ+CrIIg8c= github.com/libp2p/go-libp2p-record v0.0.1/go.mod h1:grzqg263Rug/sRex85QrDOLntdFAymLDLm7lxMgU79Q= github.com/libp2p/go-libp2p-record v0.1.0/go.mod h1:ujNc8iuE5dlKWVy6wuL6dd58t0n7xI4hAIl8pE6wu5Q= github.com/libp2p/go-libp2p-record v0.1.2 h1:M50VKzWnmUrk/M5/Dz99qO9Xh4vs8ijsK+7HkJvRP+0= github.com/libp2p/go-libp2p-record v0.1.2/go.mod h1:pal0eNcT5nqZaTV7UGhqeGqxFgGdsU/9W//C8dqjQDk= +github.com/libp2p/go-libp2p-record v0.1.3 h1:R27hoScIhQf/A8XJZ8lYpnqh9LatJ5YbHs28kCIfql0= +github.com/libp2p/go-libp2p-record v0.1.3/go.mod h1:yNUff/adKIfPnYQXgp6FQmNu3gLJ6EMg7+/vv2+9pY4= github.com/libp2p/go-libp2p-routing v0.0.1/go.mod h1:N51q3yTr4Zdr7V8Jt2JIktVU+3xBBylx1MZeVA6t1Ys= github.com/libp2p/go-libp2p-routing-helpers v0.2.3 h1:xY61alxJ6PurSi+MXbywZpelvuU4U4p/gPTxjqCqTzY= github.com/libp2p/go-libp2p-routing-helpers v0.2.3/go.mod h1:795bh+9YeoFl99rMASoiVgHdi5bjack0N1+AFAdbvBw= @@ -653,6 +739,10 @@ github.com/libp2p/go-libp2p-swarm v0.2.2 h1:T4hUpgEs2r371PweU3DuH7EOmBIdTBCwWs+F github.com/libp2p/go-libp2p-swarm v0.2.2/go.mod h1:fvmtQ0T1nErXym1/aa1uJEyN7JzaTNyBcHImCxRpPKU= github.com/libp2p/go-libp2p-swarm v0.2.3 h1:uVkCb8Blfg7HQ/f30TyHn1g/uCwXsAET7pU0U59gx/A= github.com/libp2p/go-libp2p-swarm v0.2.3/go.mod h1:P2VO/EpxRyDxtChXz/VPVXyTnszHvokHKRhfkEgFKNM= +github.com/libp2p/go-libp2p-swarm v0.2.4 h1:94XL76/tFeTdJNcIGugi+1uZo5O/a7y4i21PirwbgZI= +github.com/libp2p/go-libp2p-swarm v0.2.4/go.mod h1:/xIpHFPPh3wmSthtxdGbkHZ0OET1h/GGZes8Wku/M5Y= +github.com/libp2p/go-libp2p-swarm v0.2.6 h1:UhMXIa+yCOALQyceENEIStMlbTCzOM6aWo6vw8QW17Q= +github.com/libp2p/go-libp2p-swarm v0.2.6/go.mod h1:F9hrkZjO7dDbcEiYii/fAB1QdpLuU6h1pa4P5VNsEgc= github.com/libp2p/go-libp2p-testing v0.0.1/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E= github.com/libp2p/go-libp2p-testing v0.0.2/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E= github.com/libp2p/go-libp2p-testing v0.0.3/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E= @@ -672,6 +762,8 @@ github.com/libp2p/go-libp2p-transport-upgrader v0.1.1 h1:PZMS9lhjK9VytzMCW3tWHAX github.com/libp2p/go-libp2p-transport-upgrader v0.1.1/go.mod h1:IEtA6or8JUbsV07qPW4r01GnTenLW4oi3lOPbUMGJJA= github.com/libp2p/go-libp2p-transport-upgrader v0.2.0 h1:5EhPgQhXZNyfL22ERZTUoVp9UVVbNowWNVtELQaKCHk= github.com/libp2p/go-libp2p-transport-upgrader v0.2.0/go.mod h1:mQcrHj4asu6ArfSoMuyojOdjx73Q47cYD7s5+gZOlns= +github.com/libp2p/go-libp2p-transport-upgrader v0.3.0 h1:q3ULhsknEQ34eVDhv4YwKS8iet69ffs9+Fir6a7weN4= +github.com/libp2p/go-libp2p-transport-upgrader v0.3.0/go.mod h1:i+SKzbRnvXdVbU3D1dwydnTmKRPXiAR/fyvi1dXuL4o= github.com/libp2p/go-libp2p-yamux v0.1.2/go.mod h1:xUoV/RmYkg6BW/qGxA9XJyg+HzXFYkeXbnhjmnYzKp8= github.com/libp2p/go-libp2p-yamux v0.1.3/go.mod h1:VGSQVrqkh6y4nm0189qqxMtvyBft44MOYYPpYKXiVt4= github.com/libp2p/go-libp2p-yamux v0.2.0/go.mod h1:Db2gU+XfLpm6E4rG5uGCFX6uXA8MEXOxFcRoXUODaK8= @@ -683,6 +775,8 @@ github.com/libp2p/go-libp2p-yamux v0.2.5 h1:MuyItOqz03oi8npvjgMJxgnhllJLZnO/dKVO github.com/libp2p/go-libp2p-yamux v0.2.5/go.mod h1:Zpgj6arbyQrmZ3wxSZxfBmbdnWtbZ48OpsfmQVTErwA= github.com/libp2p/go-libp2p-yamux v0.2.7 h1:vzKu0NVtxvEIDGCv6mjKRcK0gipSgaXmJZ6jFv0d/dk= github.com/libp2p/go-libp2p-yamux v0.2.7/go.mod h1:X28ENrBMU/nm4I3Nx4sZ4dgjZ6VhLEn0XhIoZ5viCwU= +github.com/libp2p/go-libp2p-yamux v0.2.8 h1:0s3ELSLu2O7hWKfX1YjzudBKCP0kZ+m9e2+0veXzkn4= +github.com/libp2p/go-libp2p-yamux v0.2.8/go.mod h1:/t6tDqeuZf0INZMTgd0WxIRbtK2EzI2h7HbFm9eAKI4= github.com/libp2p/go-maddr-filter v0.0.1/go.mod h1:6eT12kSQMA9x2pvFQa+xesMKUBlj9VImZbj3B9FBH/Q= github.com/libp2p/go-maddr-filter v0.0.4/go.mod h1:6eT12kSQMA9x2pvFQa+xesMKUBlj9VImZbj3B9FBH/Q= github.com/libp2p/go-maddr-filter v0.0.5 h1:CW3AgbMO6vUvT4kf87y4N+0P8KUl2aqLYhrGyDUbLSg= @@ -715,6 +809,8 @@ github.com/libp2p/go-openssl v0.0.3 h1:wjlG7HvQkt4Fq4cfH33Ivpwp0omaElYEi9z26qaIk github.com/libp2p/go-openssl v0.0.3/go.mod h1:unDrJpgy3oFr+rqXsarWifmJuNnJR4chtO1HmaZjggc= github.com/libp2p/go-openssl v0.0.4 h1:d27YZvLoTyMhIN4njrkr8zMDOM4lfpHIp6A+TK9fovg= github.com/libp2p/go-openssl v0.0.4/go.mod h1:unDrJpgy3oFr+rqXsarWifmJuNnJR4chtO1HmaZjggc= +github.com/libp2p/go-openssl v0.0.5 h1:pQkejVhF0xp08D4CQUcw8t+BFJeXowja6RVcb5p++EA= +github.com/libp2p/go-openssl v0.0.5/go.mod h1:unDrJpgy3oFr+rqXsarWifmJuNnJR4chtO1HmaZjggc= github.com/libp2p/go-reuseport v0.0.1 h1:7PhkfH73VXfPJYKQ6JwS5I/eVcoyYi9IMNGc6FWpFLw= github.com/libp2p/go-reuseport v0.0.1/go.mod h1:jn6RmB1ufnQwl0Q1f+YxAj8isJgDCQzaaxIFYDhcYEA= github.com/libp2p/go-reuseport-transport v0.0.1/go.mod h1:YkbSDrvjUVDL6b8XqriyA20obEtsW9BLkuOUyQAOCbs= @@ -763,8 +859,12 @@ github.com/libp2p/go-yamux v1.3.3 h1:mWuzZRCAeTBFdynLlsYgA/EIeMOLr8XY04wa52NRhsE github.com/libp2p/go-yamux v1.3.3/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow= github.com/libp2p/go-yamux v1.3.5 h1:ibuz4naPAully0pN6J/kmUARiqLpnDQIzI/8GCOrljg= github.com/libp2p/go-yamux v1.3.5/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow= +github.com/libp2p/go-yamux v1.3.7 h1:v40A1eSPJDIZwz2AvrV3cxpTZEGDP11QJbukmEhYyQI= +github.com/libp2p/go-yamux v1.3.7/go.mod h1:fr7aVgmdNGJK+N1g+b6DW6VxzbRCjCOejR/hkmpooHE= github.com/lucas-clemente/quic-go v0.15.7 h1:Pu7To5/G9JoP1mwlrcIvfV8ByPBlCzif3MCl8+1W83I= github.com/lucas-clemente/quic-go v0.15.7/go.mod h1:Myi1OyS0FOjL3not4BxT7KN29bRkcMUV5JVVFLKtDp8= +github.com/lucas-clemente/quic-go v0.16.2 h1:A27xKWQtPTeOcIUF4EymmROkKlF/RbKBiMbflwv6RK0= +github.com/lucas-clemente/quic-go v0.16.2/go.mod h1:I0+fcNTdb9eS1ZcjQZbDVPGchJ86chcIxPALn9lEJqE= github.com/lunixbochs/vtclean v1.0.0/go.mod h1:pHhQNgMf3btfWnGBVipUOjRYhoOsdGqdm/+2c2E2WMI= github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329 h1:2gxZ0XQIU/5z3Z3bUBu+FXuk2pFbkN6tcwi/pjyaDic= @@ -784,8 +884,8 @@ github.com/mattn/go-isatty v0.0.8 h1:HLtExJ+uU2HOZ+wI0Tt5DtUDrx8yhUqDcp7fYERX4CE github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= github.com/mattn/go-isatty v0.0.11 h1:FxPOTFNqGkuDUGi3H/qkUbQO4ZiBa2brKq5r0l8TGeM= github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE= -github.com/mattn/go-runewidth v0.0.8 h1:3tS41NlGYSmhhe/8fhGRzc+z3AYCw1Fe1WAyLuujKs0= -github.com/mattn/go-runewidth v0.0.8/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= +github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0= +github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b h1:j7+1HpAFS1zy5+Q4qx1fWh90gTKwiN4QCGoY9TWyyO4= @@ -796,6 +896,8 @@ github.com/miekg/dns v1.1.12 h1:WMhc1ik4LNkTg8U9l3hI1LvxKmIL+f1+WV/SZtCbDDA= github.com/miekg/dns v1.1.12/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= github.com/miekg/dns v1.1.28 h1:gQhy5bsJa8zTlVI8lywCTZp1lguor+xevFoYlzeCTQY= github.com/miekg/dns v1.1.28/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM= +github.com/miekg/dns v1.1.29 h1:xHBEhR+t5RzcFJjBLJlax2daXOrTYtr9z4WdKEfWFzg= +github.com/miekg/dns v1.1.29/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM= github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g= github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ= github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16/go.mod h1:2FMWW+8GMoPweT6+pI63m9YE3Lmw4J71hV56Chs1E/U= @@ -819,6 +921,8 @@ github.com/mr-tron/base58 v1.1.3 h1:v+sk57XuaCKGXpWtVBX8YJzO7hMGx4Aajh4TQbdEFdc= github.com/mr-tron/base58 v1.1.3/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc= github.com/multiformats/go-base32 v0.0.3 h1:tw5+NhuwaOjJCC5Pp82QuXbrmLzWg7uxlMFp8Nq/kkI= github.com/multiformats/go-base32 v0.0.3/go.mod h1:pLiuGC8y0QR3Ue4Zug5UzK9LjgbkL8NSQj0zQ5Nz/AA= +github.com/multiformats/go-base36 v0.1.0 h1:JR6TyF7JjGd3m6FbLU2cOxhC0Li8z8dLNGQ89tUg4F4= +github.com/multiformats/go-base36 v0.1.0/go.mod h1:kFGE83c6s80PklsHO9sRn2NCoffoRdUUOENyW/Vv6sM= github.com/multiformats/go-multiaddr v0.0.1/go.mod h1:xKVEak1K9cS1VdmPZW3LSIb6lgmoS58qz/pzqmAxV44= github.com/multiformats/go-multiaddr v0.0.2/go.mod h1:xKVEak1K9cS1VdmPZW3LSIb6lgmoS58qz/pzqmAxV44= github.com/multiformats/go-multiaddr v0.0.4/go.mod h1:xKVEak1K9cS1VdmPZW3LSIb6lgmoS58qz/pzqmAxV44= @@ -829,6 +933,8 @@ github.com/multiformats/go-multiaddr v0.2.0 h1:lR52sFwcTCuQb6bTfnXF6zA2XfyYvyd+5 github.com/multiformats/go-multiaddr v0.2.0/go.mod h1:0nO36NvPpyV4QzvTLi/lafl2y95ncPj0vFwVF6k6wJ4= github.com/multiformats/go-multiaddr v0.2.1 h1:SgG/cw5vqyB5QQe5FPe2TqggU9WtrA9X4nZw7LlVqOI= github.com/multiformats/go-multiaddr v0.2.1/go.mod h1:s/Apk6IyxfvMjDafnhJgJ3/46z7tZ04iMk5wP4QMGGE= +github.com/multiformats/go-multiaddr v0.2.2 h1:XZLDTszBIJe6m0zF6ITBrEcZR73OPUhCBBS9rYAuUzI= +github.com/multiformats/go-multiaddr v0.2.2/go.mod h1:NtfXiOtHvghW9KojvtySjH5y0u0xW5UouOmQQrn6a3Y= github.com/multiformats/go-multiaddr-dns v0.0.1/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q= github.com/multiformats/go-multiaddr-dns v0.0.2/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q= github.com/multiformats/go-multiaddr-dns v0.0.3/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q= @@ -854,6 +960,8 @@ github.com/multiformats/go-multibase v0.0.1 h1:PN9/v21eLywrFWdFNsFKaU04kLJzuYzmr github.com/multiformats/go-multibase v0.0.1/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs= github.com/multiformats/go-multibase v0.0.2 h1:2pAgScmS1g9XjH7EtAfNhTuyrWYEWcxy0G5Wo85hWDA= github.com/multiformats/go-multibase v0.0.2/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs= +github.com/multiformats/go-multibase v0.0.3 h1:l/B6bJDQjvQ5G52jw4QGSYeOTZoAwIO77RblWplfIqk= +github.com/multiformats/go-multibase v0.0.3/go.mod h1:5+1R4eQrT3PkYZ24C3W2Ue2tPwIdYQD509ZjSb5y9Oc= github.com/multiformats/go-multihash v0.0.1/go.mod h1:w/5tugSrLEbWqlcgJabL3oHFKTwfvkofsjW2Qa1ct4U= github.com/multiformats/go-multihash v0.0.5/go.mod h1:lt/HCbqlQwlPBz7lv0sQCdtfcMtlJvakRUn/0Ual8po= github.com/multiformats/go-multihash v0.0.6/go.mod h1:XuKXPp8VHcTygube3OWZC+aZrA+H1IhmjoCDtJc7PXM= @@ -880,6 +988,8 @@ github.com/multiformats/go-varint v0.0.5/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXS github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJEU3ofeGjhHklVoIGuVj85JJwZ6kWPaJwCIxgnFmo= github.com/neelance/sourcemap v0.0.0-20151028013722-8c68805598ab/go.mod h1:Qr6/a/Q4r9LP1IltGz7tA7iOK1WonHEYhu1HRBA7ZiM= +github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78= +github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.8.0 h1:VkHVNpR4iVnU8XQR6DBm8BqYjN7CRzw+xKUbVVbbW9w= @@ -887,6 +997,8 @@ github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+W github.com/onsi/ginkgo v1.11.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.12.0 h1:Iw5WCbBcaAAd0fpRb1c9r5YCylv4XDoCSigm1zLevwU= github.com/onsi/ginkgo v1.12.0/go.mod h1:oUhWkIvk5aDxtKvDDuw8gItl8pKl42LzjC9KZE0HfGg= +github.com/onsi/ginkgo v1.12.1 h1:mFwc4LvZ0xpSvDZ3E+k8Yte0hLOMxXUlP+yXtJqkYfQ= +github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= github.com/onsi/gomega v1.5.0 h1:izbySO9zDPmjJ8rDjLvkA2zJHIo+HkYXHnf7eN7SSyo= github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= @@ -913,11 +1025,12 @@ github.com/prometheus/client_golang v0.8.0/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXP github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= github.com/prometheus/client_golang v0.9.2/go.mod h1:OsXs2jCmiKlQ1lTBmv21f2mNfw4xf/QclQDMrYNZzcM= github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= -github.com/prometheus/client_golang v1.5.1 h1:bdHYieyGlH+6OLEk2YQha8THib30KP0/yD0YH9m6xcA= -github.com/prometheus/client_golang v1.5.1/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU= +github.com/prometheus/client_golang v1.6.0 h1:YVPodQOcK15POxhgARIvnDRVpLcuK8mglnMrWfyrw6A= +github.com/prometheus/client_golang v1.6.0/go.mod h1:ZLOG9ck3JLRdB5MgO8f+lLTe83AXG6ro35rLTxvnIl4= github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90 h1:S/YWwWx/RA8rT8tKFRuGUZhuA90OyIBpPCXkcbwU8DE= github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M= github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/common v0.0.0-20180801064454-c7de2306084e/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro= @@ -929,12 +1042,13 @@ github.com/prometheus/procfs v0.0.0-20180725123919-05ee40e3a273/go.mod h1:c3At6R github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.0-20181204211112-1dc9a6cbc91a/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= -github.com/prometheus/procfs v0.0.8 h1:+fpWZdT24pJBiqJdAwYBjPSk+5YmQzYNPYzQsdzLkt8= -github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A= +github.com/prometheus/procfs v0.0.11 h1:DhHlBtkHWPYi8O2y31JkK0TF+DGM+51OopZjH/Ia5qI= +github.com/prometheus/procfs v0.0.11/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= +github.com/rwcarlsen/goexif v0.0.0-20190401172101-9e8deecbddbd/go.mod h1:hPqNNc0+uJM6H+SuU8sEs5K5IQeKccPqeSjfgcKGgPk= github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= github.com/shurcooL/component v0.0.0-20170202220835-f88ec8f54cc4/go.mod h1:XhFIlyj5a1fBNx5aJTbKoIq0mNaPvOagO+HjB3EtxrY= github.com/shurcooL/events v0.0.0-20181021180414-410e4ca65f48/go.mod h1:5u70Mqkb5O5cxEA8nxTsgrgLehJeAw6Oc4Ab1c/P1HM= @@ -994,6 +1108,8 @@ github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJy github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= +github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0= +github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE= github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ= github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA= @@ -1042,6 +1158,7 @@ github.com/whyrusleeping/timecache v0.0.0-20160911033111-cfcb2f1abfee/go.mod h1: github.com/whyrusleeping/yamux v1.1.5/go.mod h1:E8LnQQ8HKx5KD29HZFUwM1PxCOdPRzGwur1mcYhXcD8= github.com/x-cray/logrus-prefixed-formatter v0.5.2/go.mod h1:2duySbKsL6M18s5GU7VPsoEPHyzalCE06qoARUCeBBE= github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= +github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= go.opencensus.io v0.18.0/go.mod h1:vKdFvxhtzZ9onBp9VKHK8z/sRpBMnKAsufL7wlDrCOA= go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= @@ -1077,9 +1194,11 @@ go.uber.org/zap v1.10.0 h1:ORx85nbTijNz8ljznvCMR1ZBIPKFn3jQrag10X2AsuM= go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= go.uber.org/zap v1.14.1 h1:nYDKopTbvAPq/NrUVZwT15y2lpROBiLLyoRTbXOYWOo= go.uber.org/zap v1.14.1/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc= +go.uber.org/zap v1.15.0 h1:ZZCA22JRF2gQE5FoNmhmrf7jeJJ2uhqDUNRYKm8dvmM= +go.uber.org/zap v1.15.0/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc= go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE= -go4.org v0.0.0-20200104003542-c7e774b10ea0 h1:M6XsnQeLwG+rHQ+/rrGh3puBI3WZEy9TBWmf2H+enQA= -go4.org v0.0.0-20200104003542-c7e774b10ea0/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE= +go4.org v0.0.0-20200411211856-f5505b9728dd h1:BNJlw5kRTzdmyfh5U8F93HA2OwkP7ZGwA51eJ/0wKOU= +go4.org v0.0.0-20200411211856-f5505b9728dd/go.mod h1:CIiUVy99QCPfoE13bO4EZaz5GZMZXMSBGhxRdsvzbkg= golang.org/x/build v0.0.0-20190111050920-041ab4dc3f9d/go.mod h1:OWs+y06UdEOHN4y+MfF/py+xQ/tYqIWW03b70/CG9Rw= golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= @@ -1094,6 +1213,7 @@ golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8U golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190513172903-22d7a77e9e5f/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190618222545-ea8f1a30c443/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= @@ -1104,17 +1224,39 @@ golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d h1:1ZiEyfaQIg3Qh0EoqpwAak golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5 h1:Q7tZBpemrlsc2I7IyODzhtallWRSm4Q0d09pL6XbQtU= golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37 h1:cg5LA/zNPRzIXIWSCxQW10Rvpy94aQh3LT/ShoCpkHw= +golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= +golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= +golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek= +golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY= +golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4= +golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= +golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= +golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0= golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU= +golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs= golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f h1:J5lckAjkw6qYlOZNj90mLYNTEKDvWeuc1yieZ8qUzUE= golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs= +golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b h1:Wh+f8QHJXR411sJR8/vRBTZ7YapZaRvUcLFFJhusH0k= +golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY= +golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE= +golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o= golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc= +golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY= golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= +golang.org/x/mod v0.2.0 h1:KU7oHjnv3XNWfa5COkzUifxZmxp1TyI7ImMXqFxLwvQ= +golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20180524181706-dfa909b99c79/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -1132,7 +1274,9 @@ golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190611141213-3f473d35a33a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859 h1:R/3boaszxrf1GEUWTVDzSKVwLmSJpwZ1yqXm8j0v2QI= @@ -1141,12 +1285,21 @@ golang.org/x/net v0.0.0-20190724013045-ca1201d0de80 h1:Ao/3l156eZf2AW5wK8a7/smto golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190923162816-aa69164e4478 h1:l5EDrHhldLYb3ZRHDUhXF7Om7MvYXnkV9/iQNo1lX6g= golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e h1:3G+cUijn7XD+S4eJFddp53Pv7+slrESplyjG25HgL+k= -golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= +golang.org/x/net v0.0.0-20200519113804-d87ec0cfa476 h1:E7ct1C6/33eOdrGZKMoyntcEvs2dwZnDe30crG5vpYU= +golang.org/x/net v0.0.0-20200519113804-d87ec0cfa476/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= +golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2 h1:eDrdRpKgkcCqKZQwyZRyeFZgfqt37SL7Kv3tok06cKE= +golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A= 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= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= +golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/perf v0.0.0-20180704124530-6e6d33e29852/go.mod h1:JLpeXjPJfIyPr5TlbXLkXWLhP8nz10XfvxElABhCtcw= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -1156,6 +1309,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEha golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e h1:vcxGaoTs7kV8m5Np9uUNQin4BrLOthgV7252N8V+FwY= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a h1:WXEvlFVvvGxCJLG6REjsT03iWnKLEWinaScsxF2Vm2o= +golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -1167,29 +1322,42 @@ golang.org/x/sys v0.0.0-20190219092855-153ac476189d/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190228124157-a34e9553db1e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190302025703-b6889370fb10/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190316082340-a2f829d7f35f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190405154228-4b34438f7a67/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190524122548-abf6ff778158/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190524152521-dbbf3f1254d4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190526052359-791d8a0f4d09/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190610200419-93c9922d18ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191210023423-ac6580df4449/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae h1:/WDfKMnPU+m5M4xB+6x4kaepxRw6jWvR5iDRdvjHgy8= golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f h1:gWF768j/LaZugp8dyS4UwsslYCYz9XgFxvlgsn0n9H8= golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200509044756-6aff5f38e54f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200519105757-fe76b779f299 h1:DYfZAGf2WMFjMxbgTjaC+2HC7NkNAQs+6Q8b9WEB/F4= +golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200523222454-059865788121 h1:rITEj+UZHYC927n8GT97eC3zrpzXdb/voyeOuVKS46o= +golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= 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= @@ -1197,6 +1365,7 @@ golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= 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= golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -1206,20 +1375,39 @@ golang.org/x/tools v0.0.0-20181130052023-1c3d964395ce/go.mod h1:n7NCudcB/nEzxVGm golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190328211700-ab21143f2384 h1:TFlARGu6Czu1z7q93HTxcP1P+/ZFC/IKythI5RzrnRg= golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= +golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191030062658-86caa796c7ab/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191114200427-caa0b0f7d508 h1:0FYNp0PF9kFm/ZUrvcJiQ12IUJJG7iAc6Cu01wbKrbU= golang.org/x/tools v0.0.0-20191114200427-caa0b0f7d508/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= +golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f h1:kDxGY2VmgABOe55qheT/TFqUMtcTHnomIPS1iv3G4Ms= golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191216052735-49a3e744a425 h1:VvQyQJN0tSuecqgcIxMWnnfG5kSmgy9KZR9sW3W5QeA= golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= +golang.org/x/tools v0.0.0-20200522201501-cb1345f3a375 h1:SjQ2+AKWgZLc1xej6WSzL+Dfs5Uyd5xcZH1mGC411IA= +golang.org/x/tools v0.0.0-20200522201501-cb1345f3a375/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7 h1:9zdDQZ7Thm29KFXgAX/+yaf3eVbP7djjWp/dXAppNCc= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA= @@ -1229,22 +1417,56 @@ golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8T google.golang.org/api v0.0.0-20180910000450-7ca32eb868bf/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0= google.golang.org/api v0.0.0-20181030000543-1d582fd0359e/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0= google.golang.org/api v0.1.0/go.mod h1:UGEZY7KEX120AnNLIHFMKIo4obdJhkp2tPbaPlQx13Y= +google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= +google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= +google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg= +google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI= +google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.3.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= +google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20181029155118-b69ba1387ce2/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/genproto v0.0.0-20181202183823-bd91e49a0898/go.mod h1:7Ep/1NZk928CDR8SjdVbjWNpdIf6nzjE3BTgJDr2Atg= google.golang.org/genproto v0.0.0-20190306203927-b5d61aea6440/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE= +google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc= +google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8= +google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc= +google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c= google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw= google.golang.org/grpc v1.16.0/go.mod h1:0JHn/cJsOMiMfNA9+DeHDlAU7KAAB5GDlYFpa9MZMio= google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= +google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= +google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg= +google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= +google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= +google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= +google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= +google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= +google.golang.org/protobuf v1.21.0 h1:qdOKuR/EIArgaWNjetjgTzgVTAZ+S/WXVrq9HW9zimw= +google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM= +google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY= @@ -1267,12 +1489,17 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.5 h1:ymVxjfMaHvXD8RqPRmzHHsB3VvucivSkIAvJFDI5O3c= gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o= honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= +honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXeM= honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= +rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= sourcegraph.com/sourcegraph/go-diff v0.5.0/go.mod h1:kuch7UrkMzY0X+p9CRK03kfuPQ2zzQcaEFbx8wA8rck= diff --git a/misc/completion/ipfs-completion.bash b/misc/completion/ipfs-completion.bash index 7bb1a02327a..f0f4003645a 100644 --- a/misc/completion/ipfs-completion.bash +++ b/misc/completion/ipfs-completion.bash @@ -1,9 +1,18 @@ +_do_comp() +{ + if [[ $(type compopt) == *"builtin" ]]; then + compopt $@ + else + complete $@ + fi +} + _ipfs_comp() { COMPREPLY=( $(compgen -W "$1" -- ${word}) ) if [[ ${#COMPREPLY[@]} == 1 && ${COMPREPLY[0]} == "--"*"=" ]] ; then # If there's only one option, with =, then discard space - compopt -o nospace + _do_comp -o nospace fi } @@ -271,7 +280,7 @@ _ipfs_files_mv() _ipfs_files_complete else COMPREPLY=( / ) - [[ $COMPREPLY = */ ]] && compopt -o nospace + [[ $COMPREPLY = */ ]] && _do_comp -o nospace fi } @@ -283,7 +292,7 @@ _ipfs_files_rm() _ipfs_files_complete else COMPREPLY=( / ) - [[ $COMPREPLY = */ ]] && compopt -o nospace + [[ $COMPREPLY = */ ]] && _do_comp -o nospace fi } _ipfs_files_flush() @@ -292,7 +301,7 @@ _ipfs_files_flush() _ipfs_files_complete else COMPREPLY=( / ) - [[ $COMPREPLY = */ ]] && compopt -o nospace + [[ $COMPREPLY = */ ]] && _do_comp -o nospace fi } @@ -306,7 +315,7 @@ _ipfs_files_read() _ipfs_files_complete else COMPREPLY=( / ) - [[ $COMPREPLY = */ ]] && compopt -o nospace + [[ $COMPREPLY = */ ]] && _do_comp -o nospace fi } @@ -322,7 +331,7 @@ _ipfs_files_write() _ipfs_files_complete else COMPREPLY=( / ) - [[ $COMPREPLY = */ ]] && compopt -o nospace + [[ $COMPREPLY = */ ]] && _do_comp -o nospace fi } @@ -332,7 +341,7 @@ _ipfs_files_cp() _ipfs_files_complete else COMPREPLY=( / ) - [[ $COMPREPLY = */ ]] && compopt -o nospace + [[ $COMPREPLY = */ ]] && _do_comp -o nospace fi } @@ -346,7 +355,7 @@ _ipfs_files_ls() _ipfs_files_complete else COMPREPLY=( / ) - [[ $COMPREPLY = */ ]] && compopt -o nospace + [[ $COMPREPLY = */ ]] && _do_comp -o nospace fi } @@ -361,7 +370,7 @@ _ipfs_files_mkdir() _ipfs_files_complete else COMPREPLY=( / ) - [[ $COMPREPLY = */ ]] && compopt -o nospace + [[ $COMPREPLY = */ ]] && _do_comp -o nospace fi } @@ -373,7 +382,7 @@ _ipfs_files_stat() _ipfs_files_complete else COMPREPLY=( / ) - [[ $COMPREPLY = */ ]] && compopt -o nospace + [[ $COMPREPLY = */ ]] && _do_comp -o nospace fi } @@ -394,7 +403,7 @@ _ipfs_file_ls() _ipfs_get() { if [ "${prev}" == "--output" ] ; then - compopt -o default # Re-enable default file read + _do_comp -o default # Re-enable default file read COMPREPLY=() elif [ "${prev}" == "--compression-level" ] ; then _ipfs_comp "-1 1 2 3 4 5 6 7 8 9" # TODO: Solve autocomplete bug for "=" @@ -700,7 +709,7 @@ _ipfs_resolve() else opts="/ipns/ /ipfs/" COMPREPLY=( $(compgen -W "${opts}" -- ${word}) ) - [[ $COMPREPLY = */ ]] && compopt -o nospace + [[ $COMPREPLY = */ ]] && _do_comp -o nospace fi } @@ -751,7 +760,7 @@ _ipfs_swarm_disconnect() opts=$(for x in `ipfs swarm peers`; do echo ${x} ; done) IFS="$OLDIFS" # Reset divider to space, ' ' COMPREPLY=( $(compgen -W "${opts}" -- ${word}) ) - [[ $COMPREPLY = */ ]] && compopt -o nospace -o filenames + [[ $COMPREPLY = */ ]] && _do_comp -o nospace -o filenames } _ipfs_swarm_filters() @@ -855,7 +864,7 @@ _ipfs_hash_complete() echo "Current: ${word}" >> ~/Downloads/debug-ipfs.txt COMPREPLY=( $(compgen -W "${opts}" -- ${word}) ) echo "Suggestion: ${COMPREPLY}" >> ~/Downloads/debug-ipfs.txt - [[ $COMPREPLY = */ ]] && compopt -o nospace -o filenames # Removing whitespace after output & handle output as filenames. (Only printing the latest folder of files.) + [[ $COMPREPLY = */ ]] && _do_comp -o nospace -o filenames # Removing whitespace after output & handle output as filenames. (Only printing the latest folder of files.) return 0 } @@ -866,7 +875,7 @@ _ipfs_files_complete() opts=$(for x in `ipfs files ls ${lastDir}`; do echo ${lastDir}${x}/ ; done) # TODO: Implement "ipfs files ls -F" to get rid of frontslash after files. This does currently throw "Error: /cats/foo/ is not a directory" IFS="$OLDIFS" # Reset divider to space, ' ' COMPREPLY=( $(compgen -W "${opts}" -- ${word}) ) - [[ $COMPREPLY = */ ]] && compopt -o nospace -o filenames + [[ $COMPREPLY = */ ]] && _do_comp -o nospace -o filenames return 0 } @@ -901,7 +910,7 @@ _ipfs_multiaddr_complete() opts="/ip4/ /ip6/" COMPREPLY=( $(compgen -W "${opts}" -- ${word}) ) fi - [[ $COMPREPLY = */ ]] && compopt -o nospace -o filenames + [[ $COMPREPLY = */ ]] && _do_comp -o nospace -o filenames return 0 } @@ -913,19 +922,19 @@ _ipfs_pinned_complete() IFS="$OLDIFS" if [[ ${#COMPREPLY[*]} -eq 1 ]]; then # Only one completion, remove pretty output COMPREPLY=( ${COMPREPLY[0]/ *//} ) #Remove ' ' and everything after - [[ $COMPREPLY = */ ]] && compopt -o nospace # Removing whitespace after output + [[ $COMPREPLY = */ ]] && _do_comp -o nospace # Removing whitespace after output fi } _ipfs_filesystem_complete() { - compopt -o default # Re-enable default file read + _do_comp -o default # Re-enable default file read COMPREPLY=() } _ipfs() { COMPREPLY=() - compopt +o default # Disable default to not deny completion, see: http://stackoverflow.com/a/19062943/1216348 + _do_comp +o default # Disable default to not deny completion, see: http://stackoverflow.com/a/19062943/1216348 local word="${COMP_WORDS[COMP_CWORD]}" local prev="${COMP_WORDS[COMP_CWORD-1]}" diff --git a/misc/systemd/ipfs-sysusers.conf b/misc/systemd/ipfs-sysusers.conf new file mode 100644 index 00000000000..9d5d8575623 --- /dev/null +++ b/misc/systemd/ipfs-sysusers.conf @@ -0,0 +1,3 @@ +u ipfs - "IPFS daemon" /var/lib/ipfs +g ipfs - +m ipfs ipfs diff --git a/misc/systemd/ipfs.service b/misc/systemd/ipfs.service index 0ee585ac693..b9bd4a2e232 100644 --- a/misc/systemd/ipfs.service +++ b/misc/systemd/ipfs.service @@ -1,9 +1,40 @@ +# This file will be overwritten on package upgrades, avoid customizations here. +# +# To make persistant changes, create file in +# "/etc/systemd/system/ipfs.service.d/overwrite.conf" with +# `systemctl edit ipfs.service`. This file will be parsed after this +# file has been parsed. +# +# To overwrite a variable, like ExecStart you have to specify it once +# blank and a second time with a new value, like: +# ExecStart= +# ExecStart=/usr/bin/ipfs daemon --flag1 --flag2 +# +# For more info about custom unit files see systemd.unit(5). + [Unit] -Description=IPFS Daemon +Description=InterPlanetary File System (IPFS) daemon +Documentation=https://docs.ipfs.io/ +After=network.target [Service] + +# enable for 1-1024 port listening +#AmbientCapabilities=CAP_NET_BIND_SERVICE +# enable to specify a custom path see docs/environment-variables.md for further documentations +#Environment=IPFS_PATH=/custom/ipfs/path +# enable to specify a higher limit for open files/connections +#LimitNOFILE=1000000 + +#don't use swap +MemorySwapMax=0 + Type=notify +User=ipfs +Group=ipfs +StateDirectory=ipfs ExecStart=/usr/bin/ipfs daemon --init --migrate +Restart=on-failure KillSignal=SIGINT [Install] diff --git a/mk/golang.mk b/mk/golang.mk index 5634c1d6b5f..36d40ea6f24 100644 --- a/mk/golang.mk +++ b/mk/golang.mk @@ -1,5 +1,5 @@ # golang utilities -GO_MIN_VERSION = 1.13.8 +GO_MIN_VERSION = 1.14.2 export GO111MODULE=on diff --git a/namesys/namesys.go b/namesys/namesys.go index 933ce789db6..ac7fb0383f6 100644 --- a/namesys/namesys.go +++ b/namesys/namesys.go @@ -86,16 +86,19 @@ func (ns *mpns) Resolve(ctx context.Context, name string, options ...opts.Resolv } func (ns *mpns) ResolveAsync(ctx context.Context, name string, options ...opts.ResolveOpt) <-chan Result { - res := make(chan Result, 1) if strings.HasPrefix(name, "/ipfs/") { p, err := path.ParsePath(name) + res := make(chan Result, 1) res <- Result{p, err} + close(res) return res } if !strings.HasPrefix(name, "/") { p, err := path.ParsePath("/ipfs/" + name) + res := make(chan Result, 1) res <- Result{p, err} + close(res) return res } @@ -120,15 +123,12 @@ func (ns *mpns) resolveOnceAsync(ctx context.Context, name string, options opts. key := segments[2] if p, ok := ns.cacheGet(key); ok { + var err error if len(segments) > 3 { - var err error p, err = path.FromSegments("", strings.TrimRight(p.String(), "/"), segments[3]) - if err != nil { - emitOnceResult(ctx, out, onceResult{value: p, err: err}) - } } - out <- onceResult{value: p} + out <- onceResult{value: p, err: err} close(out) return out } @@ -180,17 +180,15 @@ func (ns *mpns) resolveOnceAsync(ctx context.Context, name string, options opts. best = res } p := res.value + err := res.err + ttl := res.ttl // Attach rest of the path if len(segments) > 3 { - var err error p, err = path.FromSegments("", strings.TrimRight(p.String(), "/"), segments[3]) - if err != nil { - emitOnceResult(ctx, out, onceResult{value: p, ttl: res.ttl, err: err}) - } } - emitOnceResult(ctx, out, onceResult{value: p, ttl: res.ttl, err: res.err}) + emitOnceResult(ctx, out, onceResult{value: p, ttl: ttl, err: err}) case <-ctx.Done(): return } diff --git a/peering/peering.go b/peering/peering.go new file mode 100644 index 00000000000..ed0b43226c0 --- /dev/null +++ b/peering/peering.go @@ -0,0 +1,290 @@ +package peering + +import ( + "context" + "errors" + "math/rand" + "sync" + "time" + + "github.com/ipfs/go-log" + "github.com/libp2p/go-libp2p-core/host" + "github.com/libp2p/go-libp2p-core/network" + "github.com/libp2p/go-libp2p-core/peer" + "github.com/multiformats/go-multiaddr" +) + +// Seed the random number generator. +// +// We don't need good randomness, but we do need randomness. +const ( + // maxBackoff is the maximum time between reconnect attempts. + maxBackoff = 10 * time.Minute + // The backoff will be cut off when we get within 10% of the actual max. + // If we go over the max, we'll adjust the delay down to a random value + // between 90-100% of the max backoff. + maxBackoffJitter = 10 // % + connmgrTag = "ipfs-peering" + // This needs to be sufficient to prevent two sides from simultaneously + // dialing. + initialDelay = 5 * time.Second +) + +var logger = log.Logger("peering") + +type state int + +const ( + stateInit state = iota + stateRunning + stateStopped +) + +// peerHandler keeps track of all state related to a specific "peering" peer. +type peerHandler struct { + peer peer.ID + host host.Host + ctx context.Context + cancel context.CancelFunc + + mu sync.Mutex + addrs []multiaddr.Multiaddr + reconnectTimer *time.Timer + + nextDelay time.Duration +} + +// setAddrs sets the addresses for this peer. +func (ph *peerHandler) setAddrs(addrs []multiaddr.Multiaddr) { + // Not strictly necessary, but it helps to not trust the calling code. + addrCopy := make([]multiaddr.Multiaddr, len(addrs)) + copy(addrCopy, addrs) + + ph.mu.Lock() + defer ph.mu.Unlock() + ph.addrs = addrCopy +} + +// getAddrs returns a shared slice of addresses for this peer. Do not modify. +func (ph *peerHandler) getAddrs() []multiaddr.Multiaddr { + ph.mu.Lock() + defer ph.mu.Unlock() + return ph.addrs +} + +// stop permanently stops the peer handler. +func (ph *peerHandler) stop() { + ph.cancel() + + ph.mu.Lock() + defer ph.mu.Unlock() + if ph.reconnectTimer != nil { + ph.reconnectTimer.Stop() + ph.reconnectTimer = nil + } +} + +func (ph *peerHandler) nextBackoff() time.Duration { + if ph.nextDelay < maxBackoff { + ph.nextDelay += ph.nextDelay/2 + time.Duration(rand.Int63n(int64(ph.nextDelay))) + } + + // If we've gone over the max backoff, reduce it under the max. + if ph.nextDelay > maxBackoff { + ph.nextDelay = maxBackoff + // randomize the backoff a bit (10%). + ph.nextDelay -= time.Duration(rand.Int63n(int64(maxBackoff) * maxBackoffJitter / 100)) + } + + return ph.nextDelay +} + +func (ph *peerHandler) reconnect() { + // Try connecting + addrs := ph.getAddrs() + logger.Debugw("reconnecting", "peer", ph.peer, "addrs", addrs) + + err := ph.host.Connect(ph.ctx, peer.AddrInfo{ID: ph.peer, Addrs: addrs}) + if err != nil { + logger.Debugw("failed to reconnect", "peer", ph.peer, "error", err) + // Ok, we failed. Extend the timeout. + ph.mu.Lock() + if ph.reconnectTimer != nil { + // Only counts if the reconnectTimer still exists. If not, a + // connection _was_ somehow established. + ph.reconnectTimer.Reset(ph.nextBackoff()) + } + // Otherwise, someone else has stopped us so we can assume that + // we're either connected or someone else will start us. + ph.mu.Unlock() + } + + // Always call this. We could have connected since we processed the + // error. + ph.stopIfConnected() +} + +func (ph *peerHandler) stopIfConnected() { + ph.mu.Lock() + defer ph.mu.Unlock() + + if ph.reconnectTimer != nil && ph.host.Network().Connectedness(ph.peer) == network.Connected { + logger.Debugw("successfully reconnected", "peer", ph.peer) + ph.reconnectTimer.Stop() + ph.reconnectTimer = nil + ph.nextDelay = initialDelay + } +} + +// startIfDisconnected is the inverse of stopIfConnected. +func (ph *peerHandler) startIfDisconnected() { + ph.mu.Lock() + defer ph.mu.Unlock() + + if ph.reconnectTimer == nil && ph.host.Network().Connectedness(ph.peer) != network.Connected { + logger.Debugw("disconnected from peer", "peer", ph.peer) + // Always start with a short timeout so we can stagger things a bit. + ph.reconnectTimer = time.AfterFunc(ph.nextBackoff(), ph.reconnect) + } +} + +// PeeringService maintains connections to specified peers, reconnecting on +// disconnect with a back-off. +type PeeringService struct { + host host.Host + + mu sync.RWMutex + peers map[peer.ID]*peerHandler + state state +} + +// NewPeeringService constructs a new peering service. Peers can be added and +// removed immediately, but connections won't be formed until `Start` is called. +func NewPeeringService(host host.Host) *PeeringService { + return &PeeringService{host: host, peers: make(map[peer.ID]*peerHandler)} +} + +// Start starts the peering service, connecting and maintaining connections to +// all registered peers. It returns an error if the service has already been +// stopped. +func (ps *PeeringService) Start() error { + ps.mu.Lock() + defer ps.mu.Unlock() + + switch ps.state { + case stateInit: + logger.Infow("starting") + case stateRunning: + return nil + case stateStopped: + return errors.New("already stopped") + } + ps.host.Network().Notify((*netNotifee)(ps)) + ps.state = stateRunning + for _, handler := range ps.peers { + go handler.startIfDisconnected() + } + return nil +} + +// Stop stops the peering service. +func (ps *PeeringService) Stop() error { + ps.host.Network().StopNotify((*netNotifee)(ps)) + + ps.mu.Lock() + defer ps.mu.Unlock() + + switch ps.state { + case stateInit, stateRunning: + logger.Infow("stopping") + for _, handler := range ps.peers { + handler.stop() + } + ps.state = stateStopped + } + return nil +} + +// AddPeer adds a peer to the peering service. This function may be safely +// called at any time: before the service is started, while running, or after it +// stops. +// +// Add peer may also be called multiple times for the same peer. The new +// addresses will replace the old. +func (ps *PeeringService) AddPeer(info peer.AddrInfo) { + ps.mu.Lock() + defer ps.mu.Unlock() + + if handler, ok := ps.peers[info.ID]; ok { + logger.Infow("updating addresses", "peer", info.ID, "addrs", info.Addrs) + handler.setAddrs(info.Addrs) + } else { + logger.Infow("peer added", "peer", info.ID, "addrs", info.Addrs) + ps.host.ConnManager().Protect(info.ID, connmgrTag) + + handler = &peerHandler{ + host: ps.host, + peer: info.ID, + addrs: info.Addrs, + nextDelay: initialDelay, + } + handler.ctx, handler.cancel = context.WithCancel(context.Background()) + ps.peers[info.ID] = handler + switch ps.state { + case stateRunning: + go handler.startIfDisconnected() + case stateStopped: + // We still construct everything in this state because + // it's easier to reason about. But we should still free + // resources. + handler.cancel() + } + } +} + +// RemovePeer removes a peer from the peering service. This function may be +// safely called at any time: before the service is started, while running, or +// after it stops. +func (ps *PeeringService) RemovePeer(id peer.ID) { + ps.mu.Lock() + defer ps.mu.Unlock() + + if handler, ok := ps.peers[id]; ok { + logger.Infow("peer removed", "peer", id) + ps.host.ConnManager().Unprotect(id, connmgrTag) + + handler.stop() + delete(ps.peers, id) + } +} + +type netNotifee PeeringService + +func (nn *netNotifee) Connected(_ network.Network, c network.Conn) { + ps := (*PeeringService)(nn) + + p := c.RemotePeer() + ps.mu.RLock() + defer ps.mu.RUnlock() + + if handler, ok := ps.peers[p]; ok { + // use a goroutine to avoid blocking events. + go handler.stopIfConnected() + } +} +func (nn *netNotifee) Disconnected(_ network.Network, c network.Conn) { + ps := (*PeeringService)(nn) + + p := c.RemotePeer() + ps.mu.RLock() + defer ps.mu.RUnlock() + + if handler, ok := ps.peers[p]; ok { + // use a goroutine to avoid blocking events. + go handler.startIfDisconnected() + } +} +func (nn *netNotifee) OpenedStream(network.Network, network.Stream) {} +func (nn *netNotifee) ClosedStream(network.Network, network.Stream) {} +func (nn *netNotifee) Listen(network.Network, multiaddr.Multiaddr) {} +func (nn *netNotifee) ListenClose(network.Network, multiaddr.Multiaddr) {} diff --git a/peering/peering_test.go b/peering/peering_test.go new file mode 100644 index 00000000000..1f21b7816a2 --- /dev/null +++ b/peering/peering_test.go @@ -0,0 +1,158 @@ +package peering + +import ( + "context" + "testing" + "time" + + "github.com/libp2p/go-libp2p" + connmgr "github.com/libp2p/go-libp2p-connmgr" + "github.com/libp2p/go-libp2p-core/host" + "github.com/libp2p/go-libp2p-core/network" + "github.com/libp2p/go-libp2p-core/peer" + + "github.com/stretchr/testify/require" +) + +func newNode(ctx context.Context, t *testing.T) host.Host { + h, err := libp2p.New( + ctx, + libp2p.ListenAddrStrings("/ip4/127.0.0.1/tcp/0"), + // We'd like to set the connection manager low water to 0, but + // that would disable the connection manager. + libp2p.ConnectionManager(connmgr.NewConnManager(1, 100, 0)), + ) + require.NoError(t, err) + return h +} + +func TestPeeringService(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + defer cancel() + + h1 := newNode(ctx, t) + ps1 := NewPeeringService(h1) + + h2 := newNode(ctx, t) + h3 := newNode(ctx, t) + h4 := newNode(ctx, t) + + // peer 1 -> 2 + ps1.AddPeer(peer.AddrInfo{ID: h2.ID(), Addrs: h2.Addrs()}) + + // We haven't started so we shouldn't have any peers. + require.Never(t, func() bool { + return len(h1.Network().Peers()) > 0 + }, 100*time.Millisecond, 1*time.Second, "expected host 1 to have no peers") + + // Use p4 to take up the one slot we have in the connection manager. + for _, h := range []host.Host{h1, h2} { + require.NoError(t, h.Connect(ctx, peer.AddrInfo{ID: h4.ID(), Addrs: h4.Addrs()})) + h.ConnManager().TagPeer(h4.ID(), "sticky-peer", 1000) + } + + // Now start. + require.NoError(t, ps1.Start()) + // starting twice is fine. + require.NoError(t, ps1.Start()) + + // We should eventually connect. + require.Eventually(t, func() bool { + return h1.Network().Connectedness(h2.ID()) == network.Connected + }, 30*time.Second, 10*time.Millisecond) + + // Now explicitly connect to p3. + require.NoError(t, h1.Connect(ctx, peer.AddrInfo{ID: h3.ID(), Addrs: h3.Addrs()})) + require.Eventually(t, func() bool { + return h1.Network().Connectedness(h2.ID()) == network.Connected + }, 30*time.Second, 100*time.Millisecond) + + require.Len(t, h1.Network().Peers(), 3) + + // force a disconnect + h1.ConnManager().TrimOpenConns(ctx) + + // Should disconnect from p3. + require.Eventually(t, func() bool { + return h1.Network().Connectedness(h3.ID()) != network.Connected + }, 5*time.Second, 10*time.Millisecond) + + // Should remain connected to p2 + require.Never(t, func() bool { + return h1.Network().Connectedness(h2.ID()) != network.Connected + }, 5*time.Second, 1*time.Second) + + // Now force h2 to disconnect (we have an asymmetric peering). + conns := h2.Network().ConnsToPeer(h1.ID()) + require.NotEmpty(t, conns) + h2.ConnManager().TrimOpenConns(ctx) + + // All conns to peer should eventually close. + for _, c := range conns { + require.Eventually(t, func() bool { + s, err := c.NewStream() + if s != nil { + _ = s.Reset() + } + return err != nil + }, 5*time.Second, 10*time.Millisecond) + } + + // Should eventually re-connect. + require.Eventually(t, func() bool { + return h1.Network().Connectedness(h2.ID()) == network.Connected + }, 30*time.Second, 1*time.Second) + + // Unprotect 2 from 1. + ps1.RemovePeer(h2.ID()) + + // Trim connections. + h1.ConnManager().TrimOpenConns(ctx) + + // Should disconnect + require.Eventually(t, func() bool { + return h1.Network().Connectedness(h2.ID()) != network.Connected + }, 5*time.Second, 10*time.Millisecond) + + // Should never reconnect. + require.Never(t, func() bool { + return h1.Network().Connectedness(h2.ID()) == network.Connected + }, 20*time.Second, 1*time.Second) + + // Until added back + ps1.AddPeer(peer.AddrInfo{ID: h2.ID(), Addrs: h2.Addrs()}) + ps1.AddPeer(peer.AddrInfo{ID: h3.ID(), Addrs: h3.Addrs()}) + require.Eventually(t, func() bool { + return h1.Network().Connectedness(h2.ID()) == network.Connected + }, 30*time.Second, 1*time.Second) + require.Eventually(t, func() bool { + return h1.Network().Connectedness(h3.ID()) == network.Connected + }, 30*time.Second, 1*time.Second) + + // Should be able to repeatedly stop. + require.NoError(t, ps1.Stop()) + require.NoError(t, ps1.Stop()) + + // Adding and removing should work after stopping. + ps1.AddPeer(peer.AddrInfo{ID: h4.ID(), Addrs: h4.Addrs()}) + ps1.RemovePeer(h2.ID()) +} + +func TestNextBackoff(t *testing.T) { + minMaxBackoff := (100 - maxBackoffJitter) / 100 * maxBackoff + for x := 0; x < 1000; x++ { + ph := peerHandler{nextDelay: time.Second} + for min, max := time.Second*3/2, time.Second*5/2; min < minMaxBackoff; min, max = min*3/2, max*5/2 { + b := ph.nextBackoff() + if b > max || b < min { + t.Errorf("expected backoff %s to be between %s and %s", b, min, max) + } + } + for i := 0; i < 100; i++ { + b := ph.nextBackoff() + if b < minMaxBackoff || b > maxBackoff { + t.Fatal("failed to stay within max bounds") + } + } + } +} diff --git a/plugin/plugin.go b/plugin/plugin.go index 35e618747ca..1ff56969920 100644 --- a/plugin/plugin.go +++ b/plugin/plugin.go @@ -5,7 +5,12 @@ type Environment struct { // Path to the IPFS repo. Repo string - // The plugin's config, if specified. + // The plugin's config, if specified in the + // Plugins.Plugins["plugin-name"].Config field of the user's go-ipfs + // config. See docs/plugins.md for details. + // + // This is an arbitrary JSON-like object unmarshaled into an interface{} + // according to https://golang.org/pkg/encoding/json/#Unmarshal. Config interface{} } diff --git a/repo/fsrepo/fsrepo.go b/repo/fsrepo/fsrepo.go index a14e96ff25c..6cd312e40aa 100644 --- a/repo/fsrepo/fsrepo.go +++ b/repo/fsrepo/fsrepo.go @@ -7,7 +7,6 @@ import ( "io/ioutil" "os" "path/filepath" - "strconv" "strings" "sync" @@ -36,7 +35,7 @@ const LockFile = "repo.lock" var log = logging.Logger("fsrepo") // version number that we are currently expecting to see -var RepoVersion = 9 +var RepoVersion = 10 var migrationInstructions = `See https://github.com/ipfs/fs-repo-migrations/blob/master/run.md Sorry for the inconvenience. In the future, these will run automatically.` @@ -359,13 +358,30 @@ func (r *FSRepo) Path() string { // SetAPIAddr writes the API Addr to the /api file. func (r *FSRepo) SetAPIAddr(addr ma.Multiaddr) error { - f, err := os.Create(filepath.Join(r.path, apiFile)) + // Create a temp file to write the address, so that we don't leave empty file when the + // program crashes after creating the file. + f, err := os.Create(filepath.Join(r.path, "."+apiFile+".tmp")) if err != nil { return err } - defer f.Close() - _, err = f.WriteString(addr.String()) + if _, err = f.WriteString(addr.String()); err != nil { + return err + } + if err = f.Close(); err != nil { + return err + } + + // Atomically rename the temp file to the correct file name. + if err = os.Rename(filepath.Join(r.path, "."+apiFile+".tmp"), filepath.Join(r.path, + apiFile)); err == nil { + return nil + } + // Remove the temp file when rename return error + if err1 := os.Remove(filepath.Join(r.path, "."+apiFile+".tmp")); err1 != nil { + return fmt.Errorf("File Rename error: %s, File remove error: %s", err.Error(), + err1.Error()) + } return err } @@ -598,6 +614,7 @@ func (r *FSRepo) SetConfigKey(key string, value interface{}) error { if err != nil { return err } + // Load into a map so we don't end up writing any additional defaults to the config file. var mapconf map[string]interface{} if err := serialize.ReadConfigFile(filename, &mapconf); err != nil { return err @@ -611,42 +628,7 @@ func (r *FSRepo) SetConfigKey(key string, value interface{}) error { return err } - // Get the type of the value associated with the key - oldValue, err := common.MapGetKV(mapconf, key) - ok := true - if err != nil { - // key-value does not exist yet - switch v := value.(type) { - case string: - value, err = strconv.ParseBool(v) - if err != nil { - value, err = strconv.Atoi(v) - if err != nil { - value, err = strconv.ParseFloat(v, 32) - if err != nil { - value = v - } - } - } - default: - } - } else { - switch oldValue.(type) { - case bool: - value, ok = value.(bool) - case int: - value, ok = value.(int) - case float32: - value, ok = value.(float32) - case string: - value, ok = value.(string) - default: - } - if !ok { - return fmt.Errorf("wrong config type, expected %T", oldValue) - } - } - + // Set the key in the map. if err := common.MapSetKV(mapconf, key, value); err != nil { return err } diff --git a/repo/fsrepo/migrations/migrations.go b/repo/fsrepo/migrations/migrations.go index bc6a4bf34cc..b099216217c 100644 --- a/repo/fsrepo/migrations/migrations.go +++ b/repo/fsrepo/migrations/migrations.go @@ -15,7 +15,7 @@ import ( "strings" ) -var DistPath = "https://ipfs.io/ipfs/QmUgfXycSjF9R8F4Tyauaz6LZ4bj5nbksg54G9GdF4fit6" +var DistPath = "https://ipfs.io/ipfs/Qmdo5m6bpQXCayzfGghyvgXJdVHSsXsCKDUo9vWktDKq3K" func init() { if dist := os.Getenv("IPFS_DIST_PATH"); dist != "" { diff --git a/test/sharness/lib/iptb-lib.sh b/test/sharness/lib/iptb-lib.sh index ab612ada7f2..3d2e95a4916 100644 --- a/test/sharness/lib/iptb-lib.sh +++ b/test/sharness/lib/iptb-lib.sh @@ -36,11 +36,11 @@ startup_cluster() { if test -n "$other_args"; then test_expect_success "start up nodes with additional args" " - iptb start -wait -- ${other_args[@]} + iptb start -wait [0-$bound] -- ${other_args[@]} " else test_expect_success "start up nodes" ' - iptb start -wait + iptb start -wait [0-$bound] ' fi diff --git a/test/sharness/t0030-mount.sh b/test/sharness/t0030-mount.sh index 4282083eec6..0c0983d0c41 100755 --- a/test/sharness/t0030-mount.sh +++ b/test/sharness/t0030-mount.sh @@ -15,6 +15,9 @@ if ! test_have_prereq FUSE; then test_done fi + +export IPFS_NS_MAP="welcome.example.com:/ipfs/$HASH_WELCOME_DOCS" + # start iptb + wait for peering NUM_NODES=5 test_expect_success 'init iptb' ' @@ -22,7 +25,6 @@ test_expect_success 'init iptb' ' ' startup_cluster $NUM_NODES - # test mount failure before mounting properly. test_expect_success "'ipfs mount' fails when there is no mount dir" ' tmp_ipfs_mount() { ipfsi 0 mount -f=not_ipfs -n=not_ipns >output 2>output.err; } && @@ -53,6 +55,18 @@ test_expect_success FUSE "'ipfs mount' output looks good" ' test_cmp expected actual ' +test_expect_success FUSE "local symlink works" ' + ipfsi 0 id -f"\n" > expected && + basename $(readlink ipns/local) > actual && + test_cmp expected actual +' + +test_expect_success FUSE "can resolve ipns names" ' + echo -n "ipfs" > expected && + cat ipns/welcome.example.com/ping > actual && + test_cmp expected actual +' + test_expect_success "mount directories cannot be removed while active" ' test_must_fail rmdir ipfs ipns 2>/dev/null ' diff --git a/test/sharness/t0031-mount-publish.sh b/test/sharness/t0031-mount-publish.sh index bfb1e030845..95b52bfe5e7 100755 --- a/test/sharness/t0031-mount-publish.sh +++ b/test/sharness/t0031-mount-publish.sh @@ -22,9 +22,9 @@ test_expect_success 'init iptb' ' ' # pre-mount publish -HASH=$(echo 'hello warld' | ipfsi 0 add -q) +HASH=$(echo 'hello warld' | ipfsi 0 add -Q -w --stdin-name "file") test_expect_success "can publish before mounting /ipns" ' - ipfsi 0 name publish '$HASH' + ipfsi 0 name publish "$HASH" ' # mount diff --git a/test/sharness/t0120-bootstrap.sh b/test/sharness/t0120-bootstrap.sh index 538c5bde0ef..892c538f11d 100755 --- a/test/sharness/t0120-bootstrap.sh +++ b/test/sharness/t0120-bootstrap.sh @@ -10,6 +10,7 @@ BP2="/dnsaddr/bootstrap.libp2p.io/p2p/QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19 BP3="/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb" BP4="/dnsaddr/bootstrap.libp2p.io/p2p/QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt" BP5="/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ" +BP6="/ip4/104.131.131.82/udp/4001/quic/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ" test_description="Test ipfs repo operations" @@ -91,10 +92,11 @@ test_bootstrap_cmd() { echo "added $BP3" >>add2_expected && echo "added $BP4" >>add2_expected && echo "added $BP5" >>add2_expected && + echo "added $BP6" >>add2_expected && test_cmp add2_expected add2_actual ' - test_bootstrap_list_cmd $BP1 $BP2 $BP3 $BP4 $BP5 + test_bootstrap_list_cmd $BP1 $BP2 $BP3 $BP4 $BP5 $BP6 test_expect_success "'ipfs bootstrap rm --all' succeeds" ' ipfs bootstrap rm --all >rm2_actual @@ -106,6 +108,7 @@ test_bootstrap_cmd() { echo "removed $BP3" >>rm2_expected && echo "removed $BP4" >>rm2_expected && echo "removed $BP5" >>rm2_expected && + echo "removed $BP6" >>rm2_expected && test_cmp rm2_expected rm2_actual ' diff --git a/test/sharness/t0125-twonode.sh b/test/sharness/t0125-twonode.sh index c70213ac770..d8fb45e44c3 100755 --- a/test/sharness/t0125-twonode.sh +++ b/test/sharness/t0125-twonode.sh @@ -89,29 +89,47 @@ test_expect_success "set up tcp testbed" ' iptb testbed create -type localipfs -count 2 -force -init ' -# Enable quic but don't use it yet. -test_expect_success "enable QUIC experiment" ' - ipfsi 0 config --json Experimental.QUIC true && - ipfsi 1 config --json Experimental.QUIC true +addrs='"[\"/ip4/127.0.0.1/tcp/0\", \"/ip4/127.0.0.1/udp/0/quic\"]"' +test_expect_success "configure addresses" ' + ipfsi 0 config --json Addresses.Swarm '"${addrs}"' && + ipfsi 1 config --json Addresses.Swarm '"${addrs}"' ' +# Test TCP transport +echo "Testing TCP" +test_expect_success "use TCP only" ' + iptb run -- ipfs config --json Swarm.Transports.Network.QUIC false && + iptb run -- ipfs config --json Swarm.Transports.Network.Relay false && + iptb run -- ipfs config --json Swarm.Transports.Network.Websocket false +' +run_advanced_test + # test multiplex muxer echo "Running advanced tests with mplex" -export LIBP2P_MUX_PREFS="/mplex/6.7.0" -run_advanced_test "--enable-mplex-experiment" -unset LIBP2P_MUX_PREFS +test_expect_success "disable yamux" ' + iptb run -- ipfs config --json Swarm.Transports.Multiplexers.Yamux false +' +run_advanced_test + +test_expect_success "re-enable yamux" ' + iptb run -- ipfs config --json Swarm.Transports.Multiplexers.Yamux null +' + +# test Noise + +echo "Running advanced tests with NOISE" +test_expect_success "use noise only" ' + iptb run -- ipfs config --json Swarm.Transports.Security.TLS false && + iptb run -- ipfs config --json Swarm.Transports.Security.Secio false +' -# test default configuration -echo "Running advanced tests with default config" run_advanced_test # test QUIC echo "Running advanced tests over QUIC" -addr1='"[\"/ip4/127.0.0.1/udp/0/quic/\"]"' -addr2='"[\"/ip4/127.0.0.1/udp/0/quic/\"]"' -test_expect_success "add QUIC swarm addresses" ' - ipfsi 0 config --json Addresses.Swarm '$addr1' && - ipfsi 1 config --json Addresses.Swarm '$addr2' +test_expect_success "use QUIC only" ' + iptb run -- ipfs config --json Swarm.Transports.Network.QUIC true && + iptb run -- ipfs config --json Swarm.Transports.Network.TCP false ' run_advanced_test diff --git a/test/sharness/t0130-multinode.sh b/test/sharness/t0130-multinode.sh index e0a27b66600..c018908d132 100755 --- a/test/sharness/t0130-multinode.sh +++ b/test/sharness/t0130-multinode.sh @@ -88,24 +88,27 @@ test_expect_success "set up /tcp testbed" ' iptb testbed create -type localipfs -count 5 -force -init ' -# test multiplex muxer -export LIBP2P_MUX_PREFS="/mplex/6.7.0" +# test default configuration run_advanced_test -unset LIBP2P_MUX_PREFS -# test default configuration +# test multiplex muxer +test_expect_success "disable yamux" ' + iptb run -- ipfs config --json Swarm.Transports.Multiplexers.Yamux false +' run_advanced_test test_expect_success "set up /ws testbed" ' iptb testbed create -type localipfs -count 5 -attr listentype,ws -force -init ' +# test default configuration +run_advanced_test + # test multiplex muxer -export LIBP2P_MUX_PREFS="/mplex/6.7.0" -run_advanced_test "--enable-mplex-experiment" -unset LIBP2P_MUX_PREFS +test_expect_success "disable yamux" ' + iptb run -- ipfs config --json Swarm.Transports.Multiplexers.Yamux false +' -# test default configuration run_advanced_test diff --git a/test/sharness/t0142-testfilter.sh b/test/sharness/t0142-testfilter.sh index 0b46e2c9556..971aa68397a 100755 --- a/test/sharness/t0142-testfilter.sh +++ b/test/sharness/t0142-testfilter.sh @@ -21,11 +21,6 @@ test_expect_success 'filter 127.0.0.0/24 on node 1' ' ' for i in $(seq 0 $(( NUM_NODES - 1 ))); do - test_expect_success 'enable quic for node $i' ' - echo "$i" - ipfsi $i config --json Experimental.QUIC true - ' - test_expect_success "change IP for node $i" ' ipfsi $i config --json "Addresses.Swarm" \ "[\"/ip4/127.0.$i.1/tcp/0\",\"/ip4/127.0.$i.1/udp/0/quic\",\"/ip4/127.0.$i.1/tcp/0/ws\"]" diff --git a/test/sharness/t0171-peering.sh b/test/sharness/t0171-peering.sh new file mode 100755 index 00000000000..9b775cb3cbe --- /dev/null +++ b/test/sharness/t0171-peering.sh @@ -0,0 +1,127 @@ +#!/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)" && + { [[ "$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 diff --git a/test/sharness/t0180-pubsub.sh b/test/sharness/t0180-pubsub.sh index abffd2d77c2..349e98d54c3 100755 --- a/test/sharness/t0180-pubsub.sh +++ b/test/sharness/t0180-pubsub.sh @@ -106,25 +106,14 @@ test_expect_success 'stop iptb' ' # Test with some nodes not signing messages. -test_expect_success 'disable signing on node 1' ' - ipfsi 1 config --json Pubsub.DisableSigning true -' - -startup_cluster $NUM_NODES --enable-pubsub-experiment -run_pubsub_tests -test_expect_success 'stop iptb' ' - iptb stop -' - -# Test strict message verification. - -test_expect_success 'enable strict signature verification on node 4' ' - ipfsi 4 config --json Pubsub.StrictSignatureVerification true +test_expect_success 'disable signing on nodes 1-3' ' + iptb run [0-3] -- ipfs config --json Pubsub.DisableSigning true ' startup_cluster $NUM_NODES --enable-pubsub-experiment test_expect_success 'set node 4 to listen on testTopic' ' + rm -f node4_actual && ipfsi 4 pubsub sub --enc=ndpayload testTopic > node4_actual & ' @@ -134,25 +123,8 @@ test_expect_success 'stop iptb' ' iptb stop ' -test_expect_success 'node 4 only got the signed message' ' - echo "testOK2" > node4_expected && - test_cmp node4_actual node4_expected -' - -# Test all nodes signing with strict verification - -test_expect_success 're-enable signing on node 1' ' - ipfsi 1 config --json Pubsub.DisableSigning false -' - -test_expect_success 'enable strict signature verification on all nodes' ' - iptb run -- ipfs config --json Pubsub.StrictSignatureVerification true -' - -startup_cluster $NUM_NODES --enable-pubsub-experiment -run_pubsub_tests -test_expect_success 'stop iptb' ' - iptb stop +test_expect_success 'node 4 got no unsigned messages' ' + test_must_be_empty node4_actual ' test_done diff --git a/test/sharness/t0190-quic-ping.sh b/test/sharness/t0190-quic-ping.sh index c16b23471f1..0c2970cb9d6 100755 --- a/test/sharness/t0190-quic-ping.sh +++ b/test/sharness/t0190-quic-ping.sh @@ -11,13 +11,8 @@ test_expect_success 'init iptb' ' iptb testbed create -type localipfs -count 2 -init ' -test_expect_success "enable QUIC experiment" ' - ipfsi 0 config --json Experimental.QUIC true && - ipfsi 1 config --json Experimental.QUIC true -' - -addr1='"[\"/ip4/127.0.0.1/udp/0/quic/\"]"' -addr2='"[\"/ip4/127.0.0.1/udp/0/quic/\"]"' +addr1='"[\"/ip4/127.0.0.1/udp/0/quic\"]"' +addr2='"[\"/ip4/127.0.0.1/udp/0/quic\"]"' test_expect_success "add QUIC swarm addresses" ' ipfsi 0 config --json Addresses.Swarm '$addr1' && ipfsi 1 config --json Addresses.Swarm '$addr2' diff --git a/test/sharness/t0191-noise.sh b/test/sharness/t0191-noise.sh new file mode 100755 index 00000000000..bffec2d80c9 --- /dev/null +++ b/test/sharness/t0191-noise.sh @@ -0,0 +1,47 @@ +#!/usr/bin/env bash + +test_description="Test ping over NOISE command" + +. lib/test-lib.sh + +test_init_ipfs + +# start iptb + wait for peering +test_expect_success 'init iptb' ' + iptb testbed create -type localipfs -count 3 -init +' + +tcp_addr='"[\"/ip4/127.0.0.1/tcp/0\"]"' +test_expect_success "configure security transports" ' +iptb run < connect_error 2>&1 && + test_should_contain "failed to negotiate security protocol" connect_error || + test_fsh cat connect_error +' + +test_expect_success 'stop iptb' ' + iptb stop +' + +test_done diff --git a/test/sharness/t0290-cid.sh b/test/sharness/t0290-cid.sh index 0659df2a20a..f1fab8df650 100755 --- a/test/sharness/t0290-cid.sh +++ b/test/sharness/t0290-cid.sh @@ -88,6 +88,8 @@ c 99 base32pad C 67 base32padupper f 102 base16 F 70 base16upper +k 107 base36 +K 75 base36upper m 109 base64 M 77 base64pad t 116 base32hexpad @@ -122,6 +124,8 @@ cat < codecs_expect 225 decred-tx 240 dash-block 241 dash-tx +61697 fil-commitment-unsealed +61698 fil-commitment-sealed EOF cat < hashes_expect diff --git a/version.go b/version.go index 22316226c24..1cecf68d627 100644 --- a/version.go +++ b/version.go @@ -4,7 +4,7 @@ package ipfs var CurrentCommit string // CurrentVersionNumber is the current application's version literal -const CurrentVersionNumber = "0.5.1" +const CurrentVersionNumber = "0.6.0" const ApiVersion = "/go-ipfs/" + CurrentVersionNumber + "/"